git.delta.rocks / jrsonnet / refs/commits / dfc47a63aff8

19indoc = "1.0.3"19indoc = "1.0.3"
20insta = "1.10.0"20insta = "1.10.0"
21anyhow = "1.0.57"21anyhow = "1.0.57"
22jrsonnet-stdlib = { path = "../jrsonnet-stdlib" }
2223

1// This file describes structure of jsonnet source code
2// It is also used to generate files in src/generated
3
4// Token names ending with `!` are considered meta, and handled specifically
5
1SourceFile = Expr6SourceFile = Expr
27
3ExprBinary =8ExprBinary =
4    lhs:Expr9    lhs:LhsExpr
5    BinaryOperator10    BinaryOperator
6    rhs:Expr11    rhs:Expr
7ExprUnary =12ExprUnary =
8    UnaryOperator13    UnaryOperator
9    rhs:Expr14    rhs:Expr
10ExprSlice =15ExprSlice =
11    Expr16    Expr
12    '['
13    SliceDesc17    SliceDesc
14    ']'
15ExprIndex =18ExprIndex =
16    Expr19    Expr
17    '.'20    '.'
18    index:Name21    index:Name
19ExprIndexExpr =22ExprIndexExpr =
20    base:Expr23    base:LhsExpr
21    '['24    '['
22    index:Expr25    index:Expr
23    ']'26    ']'
24ExprApply =27ExprApply =
25    Expr28    Expr
26    '('
27    ArgsDesc29    ArgsDesc
28    ')'
29    'tailstrict'?30    'tailstrict'?
30ExprObjExtend =31ExprObjExtend =
32    LhsExpr
31    Expr33    Expr
32    '{'
33    ObjBody
34    '}'
35ExprParened =34ExprParened =
36    '('35    '('
37    Expr36    Expr
64    '['63    '['
65    Expr64    Expr
66    ','?65    ','?
67    ForSpec
68    CompSpec*66    CompSpec*
69    ']'67    ']'
68
70ExprImport =69ExprImport =
71    'importstr' String70    ImportKind String
72|   'importbin' String
73|   'import' String
7471
72ImportKind =
73    'importstr'
74|   'importbin'
75|   'import'
76
75ExprVar =77ExprVar =
76    name:Name78    name:Name
77ExprLocal =79ExprLocal =
78    'local'80    'local'
79    (Bind (',' Bind)* ','?)81    (Bind (',' Bind)* ','?)
80    ';'82    ';'
83    Expr
84
81ExprIfThenElse =85ExprIfThenElse =
82    'if'86    'if'
83    cond:Expr87    cond:Expr
84    'then'88    'then'
85    then:Expr89    then:TrueExpr
86    ('else' else_:Expr)?90    ('else' else_:FalseExpr)?
91
87ExprFunction =92ExprFunction =
88    'function'93    'function'
89    '('94    '('
112|   ExprIntrinsic117|   ExprIntrinsic
113|   ExprString118|   ExprString
114|   ExprNumber119|   ExprNumber
120|   ExprLiteral
115|   ExprArray121|   ExprArray
116|   ExprObject122|   ExprObject
117|   ExprArrayComp123|   ExprArrayComp
130|   '<<' | '>>'136|   '<<' | '>>'
131|   '+' | '-'137|   '+' | '-'
132|   '*' | '/' | '%'138|   '*' | '/' | '%'
139|   'ERROR_NO_OPERATOR!'
133140
134UnaryOperator =141UnaryOperator =
135    '-' | '!' | '~'142    '-' | '!' | '~'
136143
144SliceDescEnd=Expr
145SliceDescStep=Expr
137SliceDesc =146SliceDesc =
147    '['
138    from:Expr?148    from:Expr?
139    ':'149    ':'
140    (150    (
141        end:Expr?151        end:SliceDescEnd?
142        (152        (
143            ':'153            ':'
144            step:Expr?154            step:SliceDescStep?
145        )?155        )?
146    )?156    )?
157    ']'
147158
148Name =159Name =
149    'ident'160    'LIT_IDENT!'
150161
151ArgsDesc =162ArgsDesc =
163    '('
152    (Arg (',' Arg)* ','?)?164    (Arg (',' Arg)* ','?)?
165    ')'
153Arg =166Arg =
154    (name:Name '=')? Expr167    (name:Name '=')? Expr
155168
156ObjBodyComp =169ObjBodyComp =
157    pre:ObjLocalPostComma*170    pre:ObjLocalPostComma*
158    '['171    '['
159    key:Expr172    key:LhsExpr
160    ']'173    ']'
161    '+'?174    '+'?
162    ':'175    ':'
163    value:Expr176    value:Expr
164    post:ObjLocalPreComma*177    post:ObjLocalPreComma*
165    ForSpec
166    CompSpec*178    CompSpec*
167ObjBodyMemberList =179ObjBodyMemberList =
168    (Member (',' Member) ','?)?180    (Member (',' Member)* ','?)?
169ObjBody =181ObjBody =
170    ObjBodyComp182    ObjBodyComp
171|   ObjBodyMemberList183|   ObjBodyMemberList
196    Expr208    Expr
197FieldMethod =209FieldMethod =
198    FieldName210    FieldName
199    '('
200    ParamsDesc211    ParamsDesc
201    ')'
202    Visibility212    Visibility
203    Expr213    Expr
204Field =214Field =
230|   'super'240|   'super'
231241
232String =242String =
233    'string_double'243    'LIT_STRING_DOUBLE!'
234|   'string_single'244|   'LIT_STRING_SINGLE!'
235|   'string_double_verbatim'245|   'LIT_STRING_DOUBLE_VERBATIM!'
236|   'string_single_verbatim'246|   'LIT_STRING_SINGLE_VERBATIM!'
237|   'string_block'247|   'LIT_STRING_BLOCK!'
238248
239Number =249Number =
240    'number'250    'LIT_FLOAT!'
251|   'META_FORCE_ENUM!'
241252
242ForSpec =253ForSpec =
243    'for'254    'for'
257    value:Expr268    value:Expr
258BindFunction =269BindFunction =
259    name:Name270    name:Name
260    '('
261    params:ParamsDesc271    params:ParamsDesc
262    ')'
263    '='272    '='
264    value:Expr273    value:Expr
265Bind =274Bind =
266    BindDestruct275    BindDestruct
267|   BindFunction276|   BindFunction
268277
269ParamsDesc =278ParamsDesc =
279    '('
270    (Param (',' Param)* ','?)?280    (Param (',' Param)* ','?)?
281    ')'
271Param =282Param =
272    Destruct283    Destruct
273    (284    (
277288
278Assertion =289Assertion =
279    'assert'290    'assert'
280    condition:Expr291    condition:LhsExpr
281    (292    (
282        ':'293        ':'
283        Expr294        message:Expr
284    )?295    )?
285296
286DestructFull =297DestructFull =
287    into:Name298    Name
288DestructSkip =299DestructSkip =
289    '?'300    '?'
290DestructArray =301DestructArray =
291    '['302    '['
292    start:(303    (
293        Destruct304        DestructArrayPart
294        (',' Destruct)*305        (',' DestructArrayPart)*
295        ','?306        ','?
296    )?307    )?
297    DestructRest?
298    ','?
299    end:(
300        Destruct
301        (',' Destruct)*
302        ','?
303    )
304    ']'308    ']'
305DestructObject =309DestructObject =
306    '{'310    '{'
314    '}'318    '}'
315Destruct =319Destruct =
316    DestructFull320    DestructFull
317    DestructSkip321|   DestructSkip
318    DestructArray322|   DestructArray
319    DestructObject323|   DestructObject
320324
325DestructArrayElement =
326    Destruct
327DestructArrayPart =
328    DestructArrayElement
329|   DestructRest
330
321DestructRest =331DestructRest =
322    '...'332    '...'
323    into:Name?333    into:Name?
332        '='342        '='
333        Expr343        Expr
334    )?344    )?
345
346// Aliases used to resolve node type conflicts
347TrueExpr=Expr
348FalseExpr=Expr
349LhsExpr=Expr
335350

1use std::marker::PhantomData;
2
3use crate::{SyntaxKind, SyntaxNode, SyntaxNodeChildren, SyntaxToken};
4
5/// The main trait to go from untyped `SyntaxNode`  to a typed ast. The
6/// conversion itself has zero runtime cost: ast and syntax nodes have exactly
7/// the same representation: a pointer to the tree root and a pointer to the
8/// node itself.
9pub trait AstNode {
10	fn can_cast(kind: SyntaxKind) -> bool
11	where
12		Self: Sized;
13
14	fn cast(syntax: SyntaxNode) -> Option<Self>
15	where
16		Self: Sized;
17
18	fn syntax(&self) -> &SyntaxNode;
19	fn clone_for_update(&self) -> Self
20	where
21		Self: Sized,
22	{
23		Self::cast(self.syntax().clone_for_update()).unwrap()
24	}
25	fn clone_subtree(&self) -> Self
26	where
27		Self: Sized,
28	{
29		Self::cast(self.syntax().clone_subtree()).unwrap()
30	}
31}
32
33/// Like `AstNode`, but wraps tokens rather than interior nodes.
1pub trait AstToken {}34pub trait AstToken {
35	fn can_cast(token: SyntaxKind) -> bool
36	where
37		Self: Sized;
38
39	fn cast(syntax: SyntaxToken) -> Option<Self>
40	where
41		Self: Sized;
42
43	fn syntax(&self) -> &SyntaxToken;
44
45	fn text(&self) -> &str {
46		self.syntax().text()
47	}
48}
49
50#[derive(Debug, Clone)]
51pub struct AstChildren<N> {
52	inner: SyntaxNodeChildren,
53	ph: PhantomData<N>,
54}
55
56impl<N> AstChildren<N> {
57	fn new(parent: &SyntaxNode) -> Self {
58		AstChildren {
59			inner: parent.children(),
60			ph: PhantomData,
61		}
62	}
63}
64
65impl<N: AstNode> Iterator for AstChildren<N> {
66	type Item = N;
67	fn next(&mut self) -> Option<N> {
68		self.inner.find_map(N::cast)
69	}
70}
71
72pub mod support {
73	use super::{AstChildren, AstNode, AstToken, SyntaxKind, SyntaxNode, SyntaxToken};
74
75	pub fn child<N: AstNode>(parent: &SyntaxNode) -> Option<N> {
76		parent.children().find_map(N::cast)
77	}
78	pub fn token_child<N: AstToken>(parent: &SyntaxNode) -> Option<N> {
79		parent.children_with_tokens().find_map(|n| match n {
80			rowan::NodeOrToken::Node(_) => None,
81			rowan::NodeOrToken::Token(t) => N::cast(t),
82		})
83	}
84
85	pub fn children<N: AstNode>(parent: &SyntaxNode) -> AstChildren<N> {
86		AstChildren::new(parent)
87	}
88
89	pub fn token(parent: &SyntaxNode, kind: SyntaxKind) -> Option<SyntaxToken> {
90		parent
91			.children_with_tokens()
92			.filter_map(|it| it.into_token())
93			.find(|it| it.kind() == kind)
94	}
95}
296

20	Or,20	Or,
21	In,21	In,
22	ObjectApply,22	ObjectApply,
23	#[allow(dead_code)]
23	Invalid,24	Invalid,
24}25}
2526

1use std::mem;1use std::mem;
22
3use rowan::{GreenNode, GreenNodeBuilder, Language};3use rowan::{GreenNodeBuilder, Language};
44
5use crate::{5use crate::{
6	lex::Lexeme,6	lex::Lexeme,
1010
11#[derive(Clone, Debug, PartialEq, Eq)]11#[derive(Clone, Debug, PartialEq, Eq)]
12pub enum Event {12pub enum Event {
13	/// Used for unfinished markers
14	Pending,
15	/// After marker is completed, Pending event is replaced with Start
13	Start {16	Start {
14		kind: SyntaxKind,17		kind: SyntaxKind,
18		/// If marker is preceded or wrapped - instead of reordering events, we
19		/// insert start event in the end of events Vec instead, and store relative offset to this event here
15		forward_parent: Option<usize>,20		forward_parent: Option<usize>,
16	},21	},
22	/// Eat token
17	Token,23	Token {
24		kind: SyntaxKind,
25	},
26	/// Position of finished node
18	Finish,27	Finish {
28		/// Same as forward_parent of Start, but for wrapping
29		wrapper: Option<usize>,
19	Placeholder,30	},
20	Error(SyntaxError),31	Error(SyntaxError),
32	/// Used for dropped markers and other things
33	Noop,
21}34}
2235
23pub(super) struct Sink<'i> {36pub(super) struct Sink<'i> {
40	}53	}
4154
42	pub(super) fn finish(mut self) -> Parse {55	pub(super) fn finish(mut self) -> Parse {
56		let mut eat_start_whitespace = false;
57		let mut depth = 0;
43		for idx in 0..self.events.len() {58		for idx in 0..self.events.len() {
44			match mem::replace(&mut self.events[idx], Event::Placeholder) {59			match mem::replace(&mut self.events[idx], Event::Noop) {
45				Event::Start {60				Event::Start {
46					kind,61					kind,
47					forward_parent,62					forward_parent,
48				} => {63				} => {
64					if depth != 0 {
65						self.skip_whitespace();
66					}
49					let mut kinds = vec![kind];67					let mut kinds = vec![kind];
5068
51					let mut idx = idx;69					let mut idx = idx;
60						forward_parent = if let Event::Start {78						forward_parent = if let Event::Start {
61							kind,79							kind,
62							forward_parent,80							forward_parent,
63						} = mem::replace(&mut self.events[idx], Event::Placeholder)81						} = mem::replace(&mut self.events[idx], Event::Noop)
64						{82						{
65							kinds.push(kind);83							kinds.push(kind);
66							forward_parent84							forward_parent
7189
72					for kind in kinds.into_iter().rev() {90					for kind in kinds.into_iter().rev() {
73						self.builder.start_node(JsonnetLanguage::kind_to_raw(kind));91						self.builder.start_node(JsonnetLanguage::kind_to_raw(kind));
92						depth += 1;
93						if depth == 1 {
94							self.skip_whitespace();
95						}
74					}96					}
97
98					eat_start_whitespace = false;
75				}99				}
76				Event::Token => self.token(),100				Event::Token { kind } => {
101					if eat_start_whitespace {
102						self.skip_whitespace();
103					}
104					self.token(kind);
105					eat_start_whitespace = true;
106				}
77				Event::Finish => {107				Event::Finish { wrapper } => {
78					self.builder.finish_node();108					self.builder.finish_node();
109					depth -= 1;
110					let mut idx = idx;
111					let mut wrapper = wrapper;
112					while let Some(w) = wrapper {
113						idx += w;
114						wrapper = if let Event::Finish { wrapper } =
115							mem::replace(&mut self.events[idx], Event::Noop)
116						{
117							self.builder.finish_node();
118							depth -= 1;
119							wrapper
120						} else {
121							unreachable!()
122						}
123					}
124					eat_start_whitespace = true;
79				}125				}
126				Event::Pending => panic!("placeholder should not end in events"),
80				Event::Placeholder => {}127				Event::Noop => {}
81				Event::Error(e) => {128				Event::Error(e) => {
82					self.errors.push(e);129					self.errors.push(e);
83				}130				}
84			}131			}
85			self.skip_whitespace();
86		}132		}
87133
88		Parse {134		Parse {
89			green_node: self.builder.finish(),135			green_node: self.builder.finish(),
90			errors: self.errors,136			errors: self.errors,
91		}137		}
92	}138	}
93	fn token(&mut self) {139	fn token(&mut self, kind: SyntaxKind) {
94		let lexeme = self.lexemes[self.offset];140		let lexeme = self.lexemes[self.offset];
95		self.builder141		self.builder
96			.token(JsonnetLanguage::kind_to_raw(lexeme.kind), lexeme.text);142			.token(JsonnetLanguage::kind_to_raw(kind), lexeme.text);
97		self.offset += 1;143		self.offset += 1;
98	}144	}
99	fn skip_whitespace(&mut self) {145	fn skip_whitespace(&mut self) {
102				break;148				break;
103			}149			}
104150
105			self.token();151			self.token(lexeme.kind);
106		}152		}
107	}153	}
108}154}

1// mod tokens;1pub mod nodes;
2// mod nodes;
3pub mod syntax_kinds;2pub mod syntax_kinds;
43

1//! This is a generated file, please do not edit manually. Changes can be1//! This is a generated file, please do not edit manually. Changes can be
2//! made in codegeneration that lives in `xtask` top-level dir.2//! made in codegeneration that lives in `xtask` top-level dir.
33
4#![allow(non_snake_case)]4#![allow(non_snake_case, clippy::match_like_matches_macro)]
5use crate::{5use crate::{
6	ast::{self, support, AstChildren, AstNode},6	ast::{support, AstChildren, AstNode, AstToken},
7	SyntaxKind::{self, *},7	SyntaxKind::{self, *},
8	SyntaxNode, SyntaxToken, T,8	SyntaxNode, SyntaxToken, T,
9};9};
13	pub(crate) syntax: SyntaxNode,13	pub(crate) syntax: SyntaxNode,
14}14}
15impl SourceFile {15impl SourceFile {
16	pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }16	pub fn expr(&self) -> Option<Expr> {
17		support::child(&self.syntax)
18	}
17}19}
1820
19#[derive(Debug, Clone, PartialEq, Eq, Hash)]21#[derive(Debug, Clone, PartialEq, Eq, Hash)]
20pub struct ExprBinary {22pub struct ExprBinary {
21	pub(crate) syntax: SyntaxNode,23	pub(crate) syntax: SyntaxNode,
22}24}
23impl ExprBinary {25impl ExprBinary {
24	pub fn lhs(&self) -> Option<Expr> { support::child(&self.syntax) }26	pub fn lhs(&self) -> Option<LhsExpr> {
27		support::child(&self.syntax)
28	}
25	pub fn binary_operator(&self) -> Option<BinaryOperator> { support::child(&self.syntax) }29	pub fn binary_operator(&self) -> Option<BinaryOperator> {
30		support::token_child(&self.syntax)
31	}
26	pub fn rhs(&self) -> Option<Expr> { support::child(&self.syntax) }32	pub fn rhs(&self) -> Option<Expr> {
33		support::child(&self.syntax)
34	}
27}35}
2836
29#[derive(Debug, Clone, PartialEq, Eq, Hash)]37#[derive(Debug, Clone, PartialEq, Eq, Hash)]
30pub struct BinaryOperator {38pub struct LhsExpr {
31	pub(crate) syntax: SyntaxNode,39	pub(crate) syntax: SyntaxNode,
32}40}
33impl BinaryOperator {41impl LhsExpr {
34	pub fn or_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![||]) }42	pub fn expr(&self) -> Option<Expr> {
35	pub fn and_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![&&]) }43		support::child(&self.syntax)
36	pub fn bit_or_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![|]) }
37	pub fn bit_xor_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![^]) }44	}
38	pub fn bit_and_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![&]) }
39	pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![==]) }
40	pub fn ne_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!=]) }
41	pub fn lt_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![<]) }
42	pub fn gt_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![>]) }
43	pub fn le_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![<=]) }
44	pub fn ge_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![>=]) }
45	pub fn in_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![in]) }
46	pub fn lhs_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![<<]) }
47	pub fn rhs_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![>>]) }
48	pub fn plus_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![+]) }
49	pub fn minus_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![-]) }
50	pub fn mul_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![*]) }
51	pub fn div_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![/]) }
52	pub fn modulo_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![%]) }
53}45}
5446
55#[derive(Debug, Clone, PartialEq, Eq, Hash)]47#[derive(Debug, Clone, PartialEq, Eq, Hash)]
56pub struct ExprUnary {48pub struct ExprUnary {
57	pub(crate) syntax: SyntaxNode,49	pub(crate) syntax: SyntaxNode,
58}50}
59impl ExprUnary {51impl ExprUnary {
60	pub fn unary_operator(&self) -> Option<UnaryOperator> { support::child(&self.syntax) }52	pub fn unary_operator(&self) -> Option<UnaryOperator> {
53		support::token_child(&self.syntax)
54	}
61	pub fn rhs(&self) -> Option<Expr> { support::child(&self.syntax) }55	pub fn rhs(&self) -> Option<Expr> {
56		support::child(&self.syntax)
57	}
62}58}
6359
64#[derive(Debug, Clone, PartialEq, Eq, Hash)]60#[derive(Debug, Clone, PartialEq, Eq, Hash)]
65pub struct UnaryOperator {
66	pub(crate) syntax: SyntaxNode,
67}
68impl UnaryOperator {
69	pub fn minus_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![-]) }
70	pub fn not_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) }
71	pub fn bit_not_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![~]) }
72}
73
74#[derive(Debug, Clone, PartialEq, Eq, Hash)]
75pub struct ExprSlice {61pub struct ExprSlice {
76	pub(crate) syntax: SyntaxNode,62	pub(crate) syntax: SyntaxNode,
77}63}
78impl ExprSlice {64impl ExprSlice {
79	pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }65	pub fn expr(&self) -> Option<Expr> {
66		support::child(&self.syntax)
80	pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }67	}
81	pub fn slice_desc(&self) -> Option<SliceDesc> { support::child(&self.syntax) }68	pub fn slice_desc(&self) -> Option<SliceDesc> {
69		support::child(&self.syntax)
82	pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }70	}
83}71}
8472
85#[derive(Debug, Clone, PartialEq, Eq, Hash)]73#[derive(Debug, Clone, PartialEq, Eq, Hash)]
86pub struct SliceDesc {74pub struct SliceDesc {
87	pub(crate) syntax: SyntaxNode,75	pub(crate) syntax: SyntaxNode,
88}76}
89impl SliceDesc {77impl SliceDesc {
90	pub fn from(&self) -> Option<Expr> { support::child(&self.syntax) }78	pub fn l_brack_token(&self) -> Option<SyntaxToken> {
79		support::token(&self.syntax, T!['['])
80	}
81	pub fn from(&self) -> Option<Expr> {
82		support::child(&self.syntax)
83	}
91	pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }84	pub fn colon_token(&self) -> Option<SyntaxToken> {
85		support::token(&self.syntax, T![:])
86	}
92	pub fn end(&self) -> Option<Expr> { support::child(&self.syntax) }87	pub fn end(&self) -> Option<SliceDescEnd> {
88		support::child(&self.syntax)
89	}
93	pub fn step(&self) -> Option<Expr> { support::child(&self.syntax) }90	pub fn step(&self) -> Option<SliceDescStep> {
91		support::child(&self.syntax)
92	}
93	pub fn r_brack_token(&self) -> Option<SyntaxToken> {
94		support::token(&self.syntax, T![']'])
95	}
94}96}
9597
96#[derive(Debug, Clone, PartialEq, Eq, Hash)]98#[derive(Debug, Clone, PartialEq, Eq, Hash)]
97pub struct ExprIndex {99pub struct ExprIndex {
98	pub(crate) syntax: SyntaxNode,100	pub(crate) syntax: SyntaxNode,
99}101}
100impl ExprIndex {102impl ExprIndex {
101	pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }103	pub fn expr(&self) -> Option<Expr> {
104		support::child(&self.syntax)
105	}
102	pub fn dot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![.]) }106	pub fn dot_token(&self) -> Option<SyntaxToken> {
107		support::token(&self.syntax, T![.])
108	}
103	pub fn index(&self) -> Option<Name> { support::child(&self.syntax) }109	pub fn index(&self) -> Option<Name> {
110		support::child(&self.syntax)
111	}
104}112}
105113
106#[derive(Debug, Clone, PartialEq, Eq, Hash)]114#[derive(Debug, Clone, PartialEq, Eq, Hash)]
107pub struct Name {115pub struct Name {
108	pub(crate) syntax: SyntaxNode,116	pub(crate) syntax: SyntaxNode,
109}117}
110impl Name {118impl Name {
111	pub fn ident_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![ident]) }119	pub fn ident_lit(&self) -> Option<SyntaxToken> {
120		support::token(&self.syntax, IDENT)
121	}
112}122}
113123
114#[derive(Debug, Clone, PartialEq, Eq, Hash)]124#[derive(Debug, Clone, PartialEq, Eq, Hash)]
115pub struct ExprIndexExpr {125pub struct ExprIndexExpr {
116	pub(crate) syntax: SyntaxNode,126	pub(crate) syntax: SyntaxNode,
117}127}
118impl ExprIndexExpr {128impl ExprIndexExpr {
119	pub fn base(&self) -> Option<Expr> { support::child(&self.syntax) }129	pub fn base(&self) -> Option<LhsExpr> {
130		support::child(&self.syntax)
131	}
120	pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }132	pub fn l_brack_token(&self) -> Option<SyntaxToken> {
133		support::token(&self.syntax, T!['['])
134	}
121	pub fn index(&self) -> Option<Expr> { support::child(&self.syntax) }135	pub fn index(&self) -> Option<Expr> {
136		support::child(&self.syntax)
137	}
122	pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }138	pub fn r_brack_token(&self) -> Option<SyntaxToken> {
139		support::token(&self.syntax, T![']'])
140	}
123}141}
124142
125#[derive(Debug, Clone, PartialEq, Eq, Hash)]143#[derive(Debug, Clone, PartialEq, Eq, Hash)]
126pub struct ExprApply {144pub struct ExprApply {
127	pub(crate) syntax: SyntaxNode,145	pub(crate) syntax: SyntaxNode,
128}146}
129impl ExprApply {147impl ExprApply {
130	pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }148	pub fn expr(&self) -> Option<Expr> {
149		support::child(&self.syntax)
131	pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }150	}
132	pub fn args_desc(&self) -> Option<ArgsDesc> { support::child(&self.syntax) }151	pub fn args_desc(&self) -> Option<ArgsDesc> {
152		support::child(&self.syntax)
133	pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }153	}
134	pub fn tailstrict_token(&self) -> Option<SyntaxToken> {154	pub fn tailstrict_kw_token(&self) -> Option<SyntaxToken> {
135		support::token(&self.syntax, T![tailstrict])155		support::token(&self.syntax, T![tailstrict])
136	}156	}
137}157}
141	pub(crate) syntax: SyntaxNode,161	pub(crate) syntax: SyntaxNode,
142}162}
143impl ArgsDesc {163impl ArgsDesc {
144	pub fn args(&self) -> AstChildren<Arg> { support::children(&self.syntax) }164	pub fn l_paren_token(&self) -> Option<SyntaxToken> {
165		support::token(&self.syntax, T!['('])
166	}
167	pub fn args(&self) -> AstChildren<Arg> {
168		support::children(&self.syntax)
169	}
170	pub fn r_paren_token(&self) -> Option<SyntaxToken> {
171		support::token(&self.syntax, T![')'])
172	}
145}173}
146174
147#[derive(Debug, Clone, PartialEq, Eq, Hash)]175#[derive(Debug, Clone, PartialEq, Eq, Hash)]
148pub struct ExprObjExtend {176pub struct ExprObjExtend {
149	pub(crate) syntax: SyntaxNode,177	pub(crate) syntax: SyntaxNode,
150}178}
151impl ExprObjExtend {179impl ExprObjExtend {
152	pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }180	pub fn lhs_expr(&self) -> Option<LhsExpr> {
181		support::child(&self.syntax)
153	pub fn l_brace_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }182	}
154	pub fn obj_body(&self) -> Option<ObjBody> { support::child(&self.syntax) }183	pub fn expr(&self) -> Option<Expr> {
184		support::child(&self.syntax)
155	pub fn r_brace_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }185	}
156}186}
157187
158#[derive(Debug, Clone, PartialEq, Eq, Hash)]188#[derive(Debug, Clone, PartialEq, Eq, Hash)]
159pub struct ExprParened {189pub struct ExprParened {
160	pub(crate) syntax: SyntaxNode,190	pub(crate) syntax: SyntaxNode,
161}191}
162impl ExprParened {192impl ExprParened {
163	pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }193	pub fn l_paren_token(&self) -> Option<SyntaxToken> {
194		support::token(&self.syntax, T!['('])
195	}
164	pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }196	pub fn expr(&self) -> Option<Expr> {
197		support::child(&self.syntax)
198	}
165	pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }199	pub fn r_paren_token(&self) -> Option<SyntaxToken> {
200		support::token(&self.syntax, T![')'])
201	}
166}202}
167203
168#[derive(Debug, Clone, PartialEq, Eq, Hash)]204#[derive(Debug, Clone, PartialEq, Eq, Hash)]
169pub struct ExprLiteral {205pub struct ExprLiteral {
170	pub(crate) syntax: SyntaxNode,206	pub(crate) syntax: SyntaxNode,
171}207}
172impl ExprLiteral {208impl ExprLiteral {
173	pub fn literal(&self) -> Option<Literal> { support::child(&self.syntax) }209	pub fn literal(&self) -> Option<Literal> {
210		support::token_child(&self.syntax)
211	}
174}212}
175213
176#[derive(Debug, Clone, PartialEq, Eq, Hash)]214#[derive(Debug, Clone, PartialEq, Eq, Hash)]
177pub struct Literal {
178	pub(crate) syntax: SyntaxNode,
179}
180impl Literal {
181	pub fn null_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![null]) }
182	pub fn true_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![true]) }
183	pub fn false_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![false]) }
184	pub fn self_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![self]) }
185	pub fn dollar_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['$']) }
186	pub fn super_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![super]) }
187}
188
189#[derive(Debug, Clone, PartialEq, Eq, Hash)]
190pub struct ExprIntrinsicThisFile {215pub struct ExprIntrinsicThisFile {
191	pub(crate) syntax: SyntaxNode,216	pub(crate) syntax: SyntaxNode,
192}217}
214	pub fn intrinsic_token(&self) -> Option<SyntaxToken> {239	pub fn intrinsic_token(&self) -> Option<SyntaxToken> {
215		support::token(&self.syntax, T!["$intrinsic"])240		support::token(&self.syntax, T!["$intrinsic"])
216	}241	}
217	pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }242	pub fn l_paren_token(&self) -> Option<SyntaxToken> {
243		support::token(&self.syntax, T!['('])
244	}
218	pub fn name(&self) -> Option<Name> { support::child(&self.syntax) }245	pub fn name(&self) -> Option<Name> {
246		support::child(&self.syntax)
247	}
219	pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }248	pub fn r_paren_token(&self) -> Option<SyntaxToken> {
249		support::token(&self.syntax, T![')'])
250	}
220}251}
221252
222#[derive(Debug, Clone, PartialEq, Eq, Hash)]253#[derive(Debug, Clone, PartialEq, Eq, Hash)]
223pub struct ExprString {254pub struct ExprString {
224	pub(crate) syntax: SyntaxNode,255	pub(crate) syntax: SyntaxNode,
225}256}
226impl ExprString {257impl ExprString {
227	pub fn string(&self) -> Option<String> { support::child(&self.syntax) }258	pub fn string(&self) -> Option<String> {
228}
229
230#[derive(Debug, Clone, PartialEq, Eq, Hash)]
231pub struct String {
232	pub(crate) syntax: SyntaxNode,259		support::token_child(&self.syntax)
233}
234impl String {
235	pub fn string_double_token(&self) -> Option<SyntaxToken> {
236		support::token(&self.syntax, T![string_double])
237	}260	}
238	pub fn string_single_token(&self) -> Option<SyntaxToken> {
239		support::token(&self.syntax, T![string_single])
240	}
241	pub fn string_double_verbatim_token(&self) -> Option<SyntaxToken> {
242		support::token(&self.syntax, T![string_double_verbatim])
243	}
244	pub fn string_single_verbatim_token(&self) -> Option<SyntaxToken> {
245		support::token(&self.syntax, T![string_single_verbatim])
246	}
247	pub fn string_block_token(&self) -> Option<SyntaxToken> {
248		support::token(&self.syntax, T![string_block])
249	}
250}261}
251262
252#[derive(Debug, Clone, PartialEq, Eq, Hash)]263#[derive(Debug, Clone, PartialEq, Eq, Hash)]
253pub struct ExprNumber {264pub struct ExprNumber {
254	pub(crate) syntax: SyntaxNode,265	pub(crate) syntax: SyntaxNode,
255}266}
256impl ExprNumber {267impl ExprNumber {
257	pub fn number(&self) -> Option<Number> { support::child(&self.syntax) }268	pub fn number(&self) -> Option<Number> {
269		support::token_child(&self.syntax)
270	}
258}271}
259272
260#[derive(Debug, Clone, PartialEq, Eq, Hash)]273#[derive(Debug, Clone, PartialEq, Eq, Hash)]
261pub struct Number {
262	pub(crate) syntax: SyntaxNode,
263}
264impl Number {
265	pub fn number_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![number]) }
266}
267
268#[derive(Debug, Clone, PartialEq, Eq, Hash)]
269pub struct ExprArray {274pub struct ExprArray {
270	pub(crate) syntax: SyntaxNode,275	pub(crate) syntax: SyntaxNode,
271}276}
272impl ExprArray {277impl ExprArray {
273	pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }278	pub fn l_brack_token(&self) -> Option<SyntaxToken> {
279		support::token(&self.syntax, T!['['])
280	}
274	pub fn exprs(&self) -> AstChildren<Expr> { support::children(&self.syntax) }281	pub fn exprs(&self) -> AstChildren<Expr> {
282		support::children(&self.syntax)
283	}
275	pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }284	pub fn r_brack_token(&self) -> Option<SyntaxToken> {
285		support::token(&self.syntax, T![']'])
286	}
276}287}
277288
278#[derive(Debug, Clone, PartialEq, Eq, Hash)]289#[derive(Debug, Clone, PartialEq, Eq, Hash)]
279pub struct ExprObject {290pub struct ExprObject {
280	pub(crate) syntax: SyntaxNode,291	pub(crate) syntax: SyntaxNode,
281}292}
282impl ExprObject {293impl ExprObject {
283	pub fn l_brace_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }294	pub fn l_brace_token(&self) -> Option<SyntaxToken> {
295		support::token(&self.syntax, T!['{'])
296	}
284	pub fn obj_body(&self) -> Option<ObjBody> { support::child(&self.syntax) }297	pub fn obj_body(&self) -> Option<ObjBody> {
298		support::child(&self.syntax)
299	}
285	pub fn r_brace_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }300	pub fn r_brace_token(&self) -> Option<SyntaxToken> {
301		support::token(&self.syntax, T!['}'])
302	}
286}303}
287304
288#[derive(Debug, Clone, PartialEq, Eq, Hash)]305#[derive(Debug, Clone, PartialEq, Eq, Hash)]
289pub struct ExprArrayComp {306pub struct ExprArrayComp {
290	pub(crate) syntax: SyntaxNode,307	pub(crate) syntax: SyntaxNode,
291}308}
292impl ExprArrayComp {309impl ExprArrayComp {
293	pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }310	pub fn l_brack_token(&self) -> Option<SyntaxToken> {
311		support::token(&self.syntax, T!['['])
312	}
294	pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }313	pub fn expr(&self) -> Option<Expr> {
314		support::child(&self.syntax)
315	}
295	pub fn comma_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![,]) }316	pub fn comma_token(&self) -> Option<SyntaxToken> {
317		support::token(&self.syntax, T![,])
296	pub fn for_spec(&self) -> Option<ForSpec> { support::child(&self.syntax) }318	}
297	pub fn comp_specs(&self) -> AstChildren<CompSpec> { support::children(&self.syntax) }319	pub fn comp_specs(&self) -> AstChildren<CompSpec> {
320		support::children(&self.syntax)
321	}
298	pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }322	pub fn r_brack_token(&self) -> Option<SyntaxToken> {
323		support::token(&self.syntax, T![']'])
324	}
299}325}
300326
301#[derive(Debug, Clone, PartialEq, Eq, Hash)]327#[derive(Debug, Clone, PartialEq, Eq, Hash)]
302pub struct ForSpec {
303	pub(crate) syntax: SyntaxNode,
304}
305impl ForSpec {
306	pub fn for_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![for]) }
307	pub fn bind(&self) -> Option<Name> { support::child(&self.syntax) }
308	pub fn in_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![in]) }
309	pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
310}
311
312#[derive(Debug, Clone, PartialEq, Eq, Hash)]
313pub struct ExprImport {328pub struct ExprImport {
314	pub(crate) syntax: SyntaxNode,329	pub(crate) syntax: SyntaxNode,
315}330}
316impl ExprImport {331impl ExprImport {
317	pub fn importstr_token(&self) -> Option<SyntaxToken> {332	pub fn import_kind(&self) -> Option<ImportKind> {
318		support::token(&self.syntax, T![importstr])333		support::token_child(&self.syntax)
319	}334	}
320	pub fn string(&self) -> Option<String> { support::child(&self.syntax) }335	pub fn string(&self) -> Option<String> {
321	pub fn importbin_token(&self) -> Option<SyntaxToken> {336		support::token_child(&self.syntax)
322		support::token(&self.syntax, T![importbin])
323	}337	}
324	pub fn import_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![import]) }
325}338}
326339
327#[derive(Debug, Clone, PartialEq, Eq, Hash)]340#[derive(Debug, Clone, PartialEq, Eq, Hash)]
328pub struct ExprVar {341pub struct ExprVar {
329	pub(crate) syntax: SyntaxNode,342	pub(crate) syntax: SyntaxNode,
330}343}
331impl ExprVar {344impl ExprVar {
332	pub fn name(&self) -> Option<Name> { support::child(&self.syntax) }345	pub fn name(&self) -> Option<Name> {
346		support::child(&self.syntax)
347	}
333}348}
334349
335#[derive(Debug, Clone, PartialEq, Eq, Hash)]350#[derive(Debug, Clone, PartialEq, Eq, Hash)]
336pub struct ExprLocal {351pub struct ExprLocal {
337	pub(crate) syntax: SyntaxNode,352	pub(crate) syntax: SyntaxNode,
338}353}
339impl ExprLocal {354impl ExprLocal {
340	pub fn local_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![local]) }355	pub fn local_kw_token(&self) -> Option<SyntaxToken> {
356		support::token(&self.syntax, T![local])
357	}
341	pub fn binds(&self) -> AstChildren<Bind> { support::children(&self.syntax) }358	pub fn binds(&self) -> AstChildren<Bind> {
359		support::children(&self.syntax)
360	}
342	pub fn semi_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }361	pub fn semi_token(&self) -> Option<SyntaxToken> {
362		support::token(&self.syntax, T![;])
363	}
364	pub fn expr(&self) -> Option<Expr> {
365		support::child(&self.syntax)
366	}
343}367}
344368
345#[derive(Debug, Clone, PartialEq, Eq, Hash)]369#[derive(Debug, Clone, PartialEq, Eq, Hash)]
346pub struct ExprIfThenElse {370pub struct ExprIfThenElse {
347	pub(crate) syntax: SyntaxNode,371	pub(crate) syntax: SyntaxNode,
348}372}
349impl ExprIfThenElse {373impl ExprIfThenElse {
350	pub fn if_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![if]) }374	pub fn if_kw_token(&self) -> Option<SyntaxToken> {
375		support::token(&self.syntax, T![if])
376	}
351	pub fn cond(&self) -> Option<Expr> { support::child(&self.syntax) }377	pub fn cond(&self) -> Option<Expr> {
378		support::child(&self.syntax)
379	}
352	pub fn then_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![then]) }380	pub fn then_kw_token(&self) -> Option<SyntaxToken> {
381		support::token(&self.syntax, T![then])
382	}
353	pub fn then(&self) -> Option<Expr> { support::child(&self.syntax) }383	pub fn then(&self) -> Option<TrueExpr> {
384		support::child(&self.syntax)
385	}
354	pub fn else_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![else]) }386	pub fn else_kw_token(&self) -> Option<SyntaxToken> {
387		support::token(&self.syntax, T![else])
388	}
355	pub fn else_(&self) -> Option<Expr> { support::child(&self.syntax) }389	pub fn else_(&self) -> Option<FalseExpr> {
390		support::child(&self.syntax)
391	}
356}392}
357393
358#[derive(Debug, Clone, PartialEq, Eq, Hash)]394#[derive(Debug, Clone, PartialEq, Eq, Hash)]
395pub struct TrueExpr {
396	pub(crate) syntax: SyntaxNode,
397}
398impl TrueExpr {
399	pub fn expr(&self) -> Option<Expr> {
400		support::child(&self.syntax)
401	}
402}
403
404#[derive(Debug, Clone, PartialEq, Eq, Hash)]
405pub struct FalseExpr {
406	pub(crate) syntax: SyntaxNode,
407}
408impl FalseExpr {
409	pub fn expr(&self) -> Option<Expr> {
410		support::child(&self.syntax)
411	}
412}
413
414#[derive(Debug, Clone, PartialEq, Eq, Hash)]
359pub struct ExprFunction {415pub struct ExprFunction {
360	pub(crate) syntax: SyntaxNode,416	pub(crate) syntax: SyntaxNode,
361}417}
362impl ExprFunction {418impl ExprFunction {
363	pub fn function_token(&self) -> Option<SyntaxToken> {419	pub fn function_kw_token(&self) -> Option<SyntaxToken> {
364		support::token(&self.syntax, T![function])420		support::token(&self.syntax, T![function])
365	}421	}
366	pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }422	pub fn l_paren_token(&self) -> Option<SyntaxToken> {
423		support::token(&self.syntax, T!['('])
424	}
367	pub fn params_desc(&self) -> Option<ParamsDesc> { support::child(&self.syntax) }425	pub fn params_desc(&self) -> Option<ParamsDesc> {
426		support::child(&self.syntax)
427	}
368	pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }428	pub fn r_paren_token(&self) -> Option<SyntaxToken> {
429		support::token(&self.syntax, T![')'])
430	}
369	pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }431	pub fn expr(&self) -> Option<Expr> {
432		support::child(&self.syntax)
433	}
370}434}
371435
372#[derive(Debug, Clone, PartialEq, Eq, Hash)]436#[derive(Debug, Clone, PartialEq, Eq, Hash)]
373pub struct ParamsDesc {437pub struct ParamsDesc {
374	pub(crate) syntax: SyntaxNode,438	pub(crate) syntax: SyntaxNode,
375}439}
376impl ParamsDesc {440impl ParamsDesc {
377	pub fn params(&self) -> AstChildren<Param> { support::children(&self.syntax) }441	pub fn l_paren_token(&self) -> Option<SyntaxToken> {
442		support::token(&self.syntax, T!['('])
443	}
444	pub fn params(&self) -> AstChildren<Param> {
445		support::children(&self.syntax)
446	}
447	pub fn r_paren_token(&self) -> Option<SyntaxToken> {
448		support::token(&self.syntax, T![')'])
449	}
378}450}
379451
380#[derive(Debug, Clone, PartialEq, Eq, Hash)]452#[derive(Debug, Clone, PartialEq, Eq, Hash)]
381pub struct ExprAssert {453pub struct ExprAssert {
382	pub(crate) syntax: SyntaxNode,454	pub(crate) syntax: SyntaxNode,
383}455}
384impl ExprAssert {456impl ExprAssert {
385	pub fn assertion(&self) -> Option<Assertion> { support::child(&self.syntax) }457	pub fn assertion(&self) -> Option<Assertion> {
458		support::child(&self.syntax)
459	}
386	pub fn semi_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }460	pub fn semi_token(&self) -> Option<SyntaxToken> {
461		support::token(&self.syntax, T![;])
462	}
387	pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }463	pub fn expr(&self) -> Option<Expr> {
464		support::child(&self.syntax)
465	}
388}466}
389467
390#[derive(Debug, Clone, PartialEq, Eq, Hash)]468#[derive(Debug, Clone, PartialEq, Eq, Hash)]
391pub struct Assertion {469pub struct Assertion {
392	pub(crate) syntax: SyntaxNode,470	pub(crate) syntax: SyntaxNode,
393}471}
394impl Assertion {472impl Assertion {
395	pub fn assert_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![assert]) }473	pub fn assert_kw_token(&self) -> Option<SyntaxToken> {
474		support::token(&self.syntax, T![assert])
475	}
396	pub fn condition(&self) -> Option<Expr> { support::child(&self.syntax) }476	pub fn condition(&self) -> Option<LhsExpr> {
477		support::child(&self.syntax)
478	}
397	pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }479	pub fn colon_token(&self) -> Option<SyntaxToken> {
480		support::token(&self.syntax, T![:])
481	}
398	pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }482	pub fn message(&self) -> Option<Expr> {
483		support::child(&self.syntax)
484	}
399}485}
400486
401#[derive(Debug, Clone, PartialEq, Eq, Hash)]487#[derive(Debug, Clone, PartialEq, Eq, Hash)]
402pub struct ExprError {488pub struct ExprError {
403	pub(crate) syntax: SyntaxNode,489	pub(crate) syntax: SyntaxNode,
404}490}
405impl ExprError {491impl ExprError {
406	pub fn error_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![error]) }492	pub fn error_kw_token(&self) -> Option<SyntaxToken> {
493		support::token(&self.syntax, T![error])
494	}
407	pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }495	pub fn expr(&self) -> Option<Expr> {
496		support::child(&self.syntax)
497	}
408}498}
409499
410#[derive(Debug, Clone, PartialEq, Eq, Hash)]500#[derive(Debug, Clone, PartialEq, Eq, Hash)]
501pub struct SliceDescEnd {
502	pub(crate) syntax: SyntaxNode,
503}
504impl SliceDescEnd {
505	pub fn expr(&self) -> Option<Expr> {
506		support::child(&self.syntax)
507	}
508}
509
510#[derive(Debug, Clone, PartialEq, Eq, Hash)]
511pub struct SliceDescStep {
512	pub(crate) syntax: SyntaxNode,
513}
514impl SliceDescStep {
515	pub fn expr(&self) -> Option<Expr> {
516		support::child(&self.syntax)
517	}
518}
519
520#[derive(Debug, Clone, PartialEq, Eq, Hash)]
411pub struct Arg {521pub struct Arg {
412	pub(crate) syntax: SyntaxNode,522	pub(crate) syntax: SyntaxNode,
413}523}
414impl Arg {524impl Arg {
415	pub fn name(&self) -> Option<Name> { support::child(&self.syntax) }525	pub fn name(&self) -> Option<Name> {
526		support::child(&self.syntax)
527	}
416	pub fn assign_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }528	pub fn assign_token(&self) -> Option<SyntaxToken> {
529		support::token(&self.syntax, T![=])
530	}
417	pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }531	pub fn expr(&self) -> Option<Expr> {
532		support::child(&self.syntax)
533	}
418}534}
419535
420#[derive(Debug, Clone, PartialEq, Eq, Hash)]536#[derive(Debug, Clone, PartialEq, Eq, Hash)]
421pub struct ObjBodyComp {537pub struct ObjBodyComp {
422	pub(crate) syntax: SyntaxNode,538	pub(crate) syntax: SyntaxNode,
423}539}
424impl ObjBodyComp {540impl ObjBodyComp {
425	pub fn pre(&self) -> AstChildren<ObjLocalPostComma> { support::children(&self.syntax) }541	pub fn pre(&self) -> AstChildren<ObjLocalPostComma> {
542		support::children(&self.syntax)
543	}
426	pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }544	pub fn l_brack_token(&self) -> Option<SyntaxToken> {
545		support::token(&self.syntax, T!['['])
546	}
427	pub fn key(&self) -> Option<Expr> { support::child(&self.syntax) }547	pub fn key(&self) -> Option<LhsExpr> {
548		support::child(&self.syntax)
549	}
428	pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }550	pub fn r_brack_token(&self) -> Option<SyntaxToken> {
551		support::token(&self.syntax, T![']'])
552	}
429	pub fn plus_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![+]) }553	pub fn plus_token(&self) -> Option<SyntaxToken> {
554		support::token(&self.syntax, T![+])
555	}
430	pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }556	pub fn colon_token(&self) -> Option<SyntaxToken> {
557		support::token(&self.syntax, T![:])
558	}
431	pub fn value(&self) -> Option<Expr> { support::child(&self.syntax) }559	pub fn value(&self) -> Option<Expr> {
560		support::child(&self.syntax)
561	}
432	pub fn post(&self) -> AstChildren<ObjLocalPreComma> { support::children(&self.syntax) }562	pub fn post(&self) -> AstChildren<ObjLocalPreComma> {
563		support::children(&self.syntax)
433	pub fn for_spec(&self) -> Option<ForSpec> { support::child(&self.syntax) }564	}
434	pub fn comp_specs(&self) -> AstChildren<CompSpec> { support::children(&self.syntax) }565	pub fn comp_specs(&self) -> AstChildren<CompSpec> {
566		support::children(&self.syntax)
567	}
435}568}
436569
437#[derive(Debug, Clone, PartialEq, Eq, Hash)]570#[derive(Debug, Clone, PartialEq, Eq, Hash)]
438pub struct ObjLocalPostComma {571pub struct ObjLocalPostComma {
439	pub(crate) syntax: SyntaxNode,572	pub(crate) syntax: SyntaxNode,
440}573}
441impl ObjLocalPostComma {574impl ObjLocalPostComma {
442	pub fn obj_local(&self) -> Option<ObjLocal> { support::child(&self.syntax) }575	pub fn obj_local(&self) -> Option<ObjLocal> {
576		support::child(&self.syntax)
577	}
443	pub fn comma_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![,]) }578	pub fn comma_token(&self) -> Option<SyntaxToken> {
579		support::token(&self.syntax, T![,])
580	}
444}581}
445582
446#[derive(Debug, Clone, PartialEq, Eq, Hash)]583#[derive(Debug, Clone, PartialEq, Eq, Hash)]
447pub struct ObjLocalPreComma {584pub struct ObjLocalPreComma {
448	pub(crate) syntax: SyntaxNode,585	pub(crate) syntax: SyntaxNode,
449}586}
450impl ObjLocalPreComma {587impl ObjLocalPreComma {
451	pub fn comma_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![,]) }588	pub fn comma_token(&self) -> Option<SyntaxToken> {
589		support::token(&self.syntax, T![,])
590	}
452	pub fn obj_local(&self) -> Option<ObjLocal> { support::child(&self.syntax) }591	pub fn obj_local(&self) -> Option<ObjLocal> {
592		support::child(&self.syntax)
593	}
453}594}
454595
455#[derive(Debug, Clone, PartialEq, Eq, Hash)]596#[derive(Debug, Clone, PartialEq, Eq, Hash)]
456pub struct ObjBodyMemberList {597pub struct ObjBodyMemberList {
457	pub(crate) syntax: SyntaxNode,598	pub(crate) syntax: SyntaxNode,
458}599}
459impl ObjBodyMemberList {600impl ObjBodyMemberList {
460	pub fn member(&self) -> Option<Member> { support::child(&self.syntax) }601	pub fn members(&self) -> AstChildren<Member> {
461	pub fn comma_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![,]) }602		support::children(&self.syntax)
603	}
462}604}
463605
464#[derive(Debug, Clone, PartialEq, Eq, Hash)]606#[derive(Debug, Clone, PartialEq, Eq, Hash)]
465pub struct ObjLocal {607pub struct ObjLocal {
466	pub(crate) syntax: SyntaxNode,608	pub(crate) syntax: SyntaxNode,
467}609}
468impl ObjLocal {610impl ObjLocal {
469	pub fn local_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![local]) }611	pub fn local_kw_token(&self) -> Option<SyntaxToken> {
612		support::token(&self.syntax, T![local])
613	}
470	pub fn bind(&self) -> Option<Bind> { support::child(&self.syntax) }614	pub fn bind(&self) -> Option<Bind> {
615		support::child(&self.syntax)
616	}
471}617}
472618
473#[derive(Debug, Clone, PartialEq, Eq, Hash)]619#[derive(Debug, Clone, PartialEq, Eq, Hash)]
474pub struct MemberBindStmt {620pub struct MemberBindStmt {
475	pub(crate) syntax: SyntaxNode,621	pub(crate) syntax: SyntaxNode,
476}622}
477impl MemberBindStmt {623impl MemberBindStmt {
478	pub fn obj_local(&self) -> Option<ObjLocal> { support::child(&self.syntax) }624	pub fn obj_local(&self) -> Option<ObjLocal> {
625		support::child(&self.syntax)
626	}
479}627}
480628
481#[derive(Debug, Clone, PartialEq, Eq, Hash)]629#[derive(Debug, Clone, PartialEq, Eq, Hash)]
482pub struct MemberAssertStmt {630pub struct MemberAssertStmt {
483	pub(crate) syntax: SyntaxNode,631	pub(crate) syntax: SyntaxNode,
484}632}
485impl MemberAssertStmt {633impl MemberAssertStmt {
486	pub fn assertion(&self) -> Option<Assertion> { support::child(&self.syntax) }634	pub fn assertion(&self) -> Option<Assertion> {
635		support::child(&self.syntax)
636	}
487}637}
488638
489#[derive(Debug, Clone, PartialEq, Eq, Hash)]639#[derive(Debug, Clone, PartialEq, Eq, Hash)]
490pub struct MemberField {640pub struct MemberField {
491	pub(crate) syntax: SyntaxNode,641	pub(crate) syntax: SyntaxNode,
492}642}
493impl MemberField {643impl MemberField {
494	pub fn field(&self) -> Option<Field> { support::child(&self.syntax) }644	pub fn field(&self) -> Option<Field> {
645		support::child(&self.syntax)
646	}
495}647}
496648
497#[derive(Debug, Clone, PartialEq, Eq, Hash)]649#[derive(Debug, Clone, PartialEq, Eq, Hash)]
498pub struct FieldNormal {650pub struct FieldNormal {
499	pub(crate) syntax: SyntaxNode,651	pub(crate) syntax: SyntaxNode,
500}652}
501impl FieldNormal {653impl FieldNormal {
502	pub fn field_name(&self) -> Option<FieldName> { support::child(&self.syntax) }654	pub fn field_name(&self) -> Option<FieldName> {
503	pub fn plus_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![+]) }655		support::child(&self.syntax)
504	pub fn visibility(&self) -> Option<Visibility> { support::child(&self.syntax) }
505	pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
506}
507
508#[derive(Debug, Clone, PartialEq, Eq, Hash)]
509pub struct Visibility {
510	pub(crate) syntax: SyntaxNode,
511}
512impl Visibility {
513	pub fn coloncoloncolon_token(&self) -> Option<SyntaxToken> {
514		support::token(&self.syntax, T![:::])
515	}656	}
516	pub fn coloncolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![::]) }657	pub fn plus_token(&self) -> Option<SyntaxToken> {
658		support::token(&self.syntax, T![+])
659	}
517	pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }660	pub fn visibility(&self) -> Option<Visibility> {
661		support::token_child(&self.syntax)
662	}
663	pub fn expr(&self) -> Option<Expr> {
664		support::child(&self.syntax)
665	}
518}666}
519667
520#[derive(Debug, Clone, PartialEq, Eq, Hash)]668#[derive(Debug, Clone, PartialEq, Eq, Hash)]
521pub struct FieldMethod {669pub struct FieldMethod {
522	pub(crate) syntax: SyntaxNode,670	pub(crate) syntax: SyntaxNode,
523}671}
524impl FieldMethod {672impl FieldMethod {
525	pub fn field_name(&self) -> Option<FieldName> { support::child(&self.syntax) }673	pub fn field_name(&self) -> Option<FieldName> {
674		support::child(&self.syntax)
526	pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }675	}
527	pub fn params_desc(&self) -> Option<ParamsDesc> { support::child(&self.syntax) }676	pub fn params_desc(&self) -> Option<ParamsDesc> {
677		support::child(&self.syntax)
528	pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }678	}
529	pub fn visibility(&self) -> Option<Visibility> { support::child(&self.syntax) }679	pub fn visibility(&self) -> Option<Visibility> {
680		support::token_child(&self.syntax)
681	}
530	pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }682	pub fn expr(&self) -> Option<Expr> {
683		support::child(&self.syntax)
684	}
531}685}
532686
533#[derive(Debug, Clone, PartialEq, Eq, Hash)]687#[derive(Debug, Clone, PartialEq, Eq, Hash)]
534pub struct FieldNameFixed {688pub struct FieldNameFixed {
535	pub(crate) syntax: SyntaxNode,689	pub(crate) syntax: SyntaxNode,
536}690}
537impl FieldNameFixed {691impl FieldNameFixed {
538	pub fn id(&self) -> Option<Name> { support::child(&self.syntax) }692	pub fn id(&self) -> Option<Name> {
693		support::child(&self.syntax)
694	}
539	pub fn string(&self) -> Option<String> { support::child(&self.syntax) }695	pub fn string(&self) -> Option<String> {
696		support::token_child(&self.syntax)
697	}
540}698}
541699
542#[derive(Debug, Clone, PartialEq, Eq, Hash)]700#[derive(Debug, Clone, PartialEq, Eq, Hash)]
543pub struct FieldNameDynamic {701pub struct FieldNameDynamic {
544	pub(crate) syntax: SyntaxNode,702	pub(crate) syntax: SyntaxNode,
545}703}
546impl FieldNameDynamic {704impl FieldNameDynamic {
547	pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }705	pub fn l_brack_token(&self) -> Option<SyntaxToken> {
706		support::token(&self.syntax, T!['['])
707	}
548	pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }708	pub fn expr(&self) -> Option<Expr> {
709		support::child(&self.syntax)
710	}
549	pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }711	pub fn r_brack_token(&self) -> Option<SyntaxToken> {
712		support::token(&self.syntax, T![']'])
713	}
550}714}
551715
552#[derive(Debug, Clone, PartialEq, Eq, Hash)]716#[derive(Debug, Clone, PartialEq, Eq, Hash)]
553pub struct IfSpec {717pub struct ForSpec {
554	pub(crate) syntax: SyntaxNode,718	pub(crate) syntax: SyntaxNode,
555}719}
556impl IfSpec {720impl ForSpec {
557	pub fn if_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![if]) }721	pub fn for_kw_token(&self) -> Option<SyntaxToken> {
722		support::token(&self.syntax, T![for])
723	}
724	pub fn bind(&self) -> Option<Name> {
725		support::child(&self.syntax)
726	}
558	pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }727	pub fn in_kw_token(&self) -> Option<SyntaxToken> {
728		support::token(&self.syntax, T![in])
729	}
730	pub fn expr(&self) -> Option<Expr> {
731		support::child(&self.syntax)
732	}
559}733}
560734
561#[derive(Debug, Clone, PartialEq, Eq, Hash)]735#[derive(Debug, Clone, PartialEq, Eq, Hash)]
562pub struct BindDestruct {736pub struct IfSpec {
563	pub(crate) syntax: SyntaxNode,737	pub(crate) syntax: SyntaxNode,
564}738}
565impl BindDestruct {739impl IfSpec {
566	pub fn into(&self) -> Option<Destruct> { support::child(&self.syntax) }740	pub fn if_kw_token(&self) -> Option<SyntaxToken> {
567	pub fn assign_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }741		support::token(&self.syntax, T![if])
742	}
568	pub fn value(&self) -> Option<Expr> { support::child(&self.syntax) }743	pub fn expr(&self) -> Option<Expr> {
744		support::child(&self.syntax)
745	}
569}746}
570747
571#[derive(Debug, Clone, PartialEq, Eq, Hash)]748#[derive(Debug, Clone, PartialEq, Eq, Hash)]
572pub struct Destruct {749pub struct BindDestruct {
573	pub(crate) syntax: SyntaxNode,750	pub(crate) syntax: SyntaxNode,
574}751}
575impl Destruct {752impl BindDestruct {
576	pub fn destruct_full(&self) -> Option<DestructFull> { support::child(&self.syntax) }753	pub fn into(&self) -> Option<Destruct> {
577	pub fn destruct_skip(&self) -> Option<DestructSkip> { support::child(&self.syntax) }754		support::child(&self.syntax)
755	}
578	pub fn destruct_array(&self) -> Option<DestructArray> { support::child(&self.syntax) }756	pub fn assign_token(&self) -> Option<SyntaxToken> {
757		support::token(&self.syntax, T![=])
758	}
579	pub fn destruct_object(&self) -> Option<DestructObject> { support::child(&self.syntax) }759	pub fn value(&self) -> Option<Expr> {
760		support::child(&self.syntax)
761	}
580}762}
581763
582#[derive(Debug, Clone, PartialEq, Eq, Hash)]764#[derive(Debug, Clone, PartialEq, Eq, Hash)]
583pub struct BindFunction {765pub struct BindFunction {
584	pub(crate) syntax: SyntaxNode,766	pub(crate) syntax: SyntaxNode,
585}767}
586impl BindFunction {768impl BindFunction {
587	pub fn name(&self) -> Option<Name> { support::child(&self.syntax) }769	pub fn name(&self) -> Option<Name> {
770		support::child(&self.syntax)
588	pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }771	}
589	pub fn params(&self) -> Option<ParamsDesc> { support::child(&self.syntax) }772	pub fn params(&self) -> Option<ParamsDesc> {
773		support::child(&self.syntax)
590	pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }774	}
591	pub fn assign_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }775	pub fn assign_token(&self) -> Option<SyntaxToken> {
776		support::token(&self.syntax, T![=])
777	}
592	pub fn value(&self) -> Option<Expr> { support::child(&self.syntax) }778	pub fn value(&self) -> Option<Expr> {
779		support::child(&self.syntax)
780	}
593}781}
594782
595#[derive(Debug, Clone, PartialEq, Eq, Hash)]783#[derive(Debug, Clone, PartialEq, Eq, Hash)]
596pub struct Param {784pub struct Param {
597	pub(crate) syntax: SyntaxNode,785	pub(crate) syntax: SyntaxNode,
598}786}
599impl Param {787impl Param {
600	pub fn destruct(&self) -> Option<Destruct> { support::child(&self.syntax) }788	pub fn destruct(&self) -> Option<Destruct> {
789		support::child(&self.syntax)
790	}
601	pub fn assign_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }791	pub fn assign_token(&self) -> Option<SyntaxToken> {
792		support::token(&self.syntax, T![=])
793	}
602	pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }794	pub fn expr(&self) -> Option<Expr> {
795		support::child(&self.syntax)
796	}
603}797}
604798
605#[derive(Debug, Clone, PartialEq, Eq, Hash)]799#[derive(Debug, Clone, PartialEq, Eq, Hash)]
606pub struct DestructFull {800pub struct DestructFull {
607	pub(crate) syntax: SyntaxNode,801	pub(crate) syntax: SyntaxNode,
608}802}
609impl DestructFull {803impl DestructFull {
610	pub fn into(&self) -> Option<Name> { support::child(&self.syntax) }804	pub fn name(&self) -> Option<Name> {
805		support::child(&self.syntax)
806	}
611}807}
612808
613#[derive(Debug, Clone, PartialEq, Eq, Hash)]809#[derive(Debug, Clone, PartialEq, Eq, Hash)]
614pub struct DestructSkip {810pub struct DestructSkip {
615	pub(crate) syntax: SyntaxNode,811	pub(crate) syntax: SyntaxNode,
616}812}
617impl DestructSkip {813impl DestructSkip {
618	pub fn question_mark_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![?]) }814	pub fn question_mark_token(&self) -> Option<SyntaxToken> {
815		support::token(&self.syntax, T![?])
816	}
619}817}
620818
621#[derive(Debug, Clone, PartialEq, Eq, Hash)]819#[derive(Debug, Clone, PartialEq, Eq, Hash)]
622pub struct DestructArray {820pub struct DestructArray {
623	pub(crate) syntax: SyntaxNode,821	pub(crate) syntax: SyntaxNode,
624}822}
625impl DestructArray {823impl DestructArray {
626	pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }824	pub fn l_brack_token(&self) -> Option<SyntaxToken> {
825		support::token(&self.syntax, T!['['])
627	pub fn start(&self) -> AstChildren<Destruct> { support::children(&self.syntax) }826	}
628	pub fn destruct_rest(&self) -> Option<DestructRest> { support::child(&self.syntax) }827	pub fn destruct_array_parts(&self) -> AstChildren<DestructArrayPart> {
629	pub fn comma_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![,]) }828		support::children(&self.syntax)
630	pub fn end(&self) -> AstChildren<Destruct> { support::children(&self.syntax) }829	}
631	pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }830	pub fn r_brack_token(&self) -> Option<SyntaxToken> {
831		support::token(&self.syntax, T![']'])
832	}
632}833}
633834
634#[derive(Debug, Clone, PartialEq, Eq, Hash)]835#[derive(Debug, Clone, PartialEq, Eq, Hash)]
635pub struct DestructRest {
636	pub(crate) syntax: SyntaxNode,
637}
638impl DestructRest {
639	pub fn dotdotdot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![...]) }
640	pub fn into(&self) -> Option<Name> { support::child(&self.syntax) }
641}
642
643#[derive(Debug, Clone, PartialEq, Eq, Hash)]
644pub struct DestructObject {836pub struct DestructObject {
645	pub(crate) syntax: SyntaxNode,837	pub(crate) syntax: SyntaxNode,
646}838}
647impl DestructObject {839impl DestructObject {
648	pub fn l_brace_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }840	pub fn l_brace_token(&self) -> Option<SyntaxToken> {
841		support::token(&self.syntax, T!['{'])
842	}
649	pub fn destruct_object_fields(&self) -> AstChildren<DestructObjectField> {843	pub fn destruct_object_fields(&self) -> AstChildren<DestructObjectField> {
650		support::children(&self.syntax)844		support::children(&self.syntax)
651	}845	}
652	pub fn destruct_rest(&self) -> Option<DestructRest> { support::child(&self.syntax) }846	pub fn destruct_rest(&self) -> Option<DestructRest> {
847		support::child(&self.syntax)
848	}
653	pub fn comma_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![,]) }849	pub fn comma_token(&self) -> Option<SyntaxToken> {
850		support::token(&self.syntax, T![,])
851	}
654	pub fn r_brace_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }852	pub fn r_brace_token(&self) -> Option<SyntaxToken> {
853		support::token(&self.syntax, T!['}'])
854	}
655}855}
656856
657#[derive(Debug, Clone, PartialEq, Eq, Hash)]857#[derive(Debug, Clone, PartialEq, Eq, Hash)]
658pub struct DestructObjectField {858pub struct DestructObjectField {
659	pub(crate) syntax: SyntaxNode,859	pub(crate) syntax: SyntaxNode,
660}860}
661impl DestructObjectField {861impl DestructObjectField {
662	pub fn field(&self) -> Option<Name> { support::child(&self.syntax) }862	pub fn field(&self) -> Option<Name> {
863		support::child(&self.syntax)
864	}
663	pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }865	pub fn colon_token(&self) -> Option<SyntaxToken> {
866		support::token(&self.syntax, T![:])
867	}
664	pub fn destruct(&self) -> Option<Destruct> { support::child(&self.syntax) }868	pub fn destruct(&self) -> Option<Destruct> {
869		support::child(&self.syntax)
870	}
665	pub fn assign_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }871	pub fn assign_token(&self) -> Option<SyntaxToken> {
872		support::token(&self.syntax, T![=])
873	}
666	pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }874	pub fn expr(&self) -> Option<Expr> {
875		support::child(&self.syntax)
876	}
667}877}
668878
669#[derive(Debug, Clone, PartialEq, Eq, Hash)]879#[derive(Debug, Clone, PartialEq, Eq, Hash)]
880pub struct DestructRest {
881	pub(crate) syntax: SyntaxNode,
882}
883impl DestructRest {
884	pub fn dotdotdot_token(&self) -> Option<SyntaxToken> {
885		support::token(&self.syntax, T![...])
886	}
887	pub fn into(&self) -> Option<Name> {
888		support::child(&self.syntax)
889	}
890}
891
892#[derive(Debug, Clone, PartialEq, Eq, Hash)]
893pub struct DestructArrayElement {
894	pub(crate) syntax: SyntaxNode,
895}
896impl DestructArrayElement {
897	pub fn destruct(&self) -> Option<Destruct> {
898		support::child(&self.syntax)
899	}
900}
901
902#[derive(Debug, Clone, PartialEq, Eq, Hash)]
670pub enum Expr {903pub enum Expr {
671	ExprBinary(ExprBinary),904	ExprBinary(ExprBinary),
672	ExprUnary(ExprUnary),905	ExprUnary(ExprUnary),
681	ExprIntrinsic(ExprIntrinsic),914	ExprIntrinsic(ExprIntrinsic),
682	ExprString(ExprString),915	ExprString(ExprString),
683	ExprNumber(ExprNumber),916	ExprNumber(ExprNumber),
917	ExprLiteral(ExprLiteral),
684	ExprArray(ExprArray),918	ExprArray(ExprArray),
685	ExprObject(ExprObject),919	ExprObject(ExprObject),
686	ExprArrayComp(ExprArrayComp),920	ExprArrayComp(ExprArrayComp),
729	FieldNameFixed(FieldNameFixed),963	FieldNameFixed(FieldNameFixed),
730	FieldNameDynamic(FieldNameDynamic),964	FieldNameDynamic(FieldNameDynamic),
731}965}
966
967#[derive(Debug, Clone, PartialEq, Eq, Hash)]
968pub enum Destruct {
969	DestructFull(DestructFull),
970	DestructSkip(DestructSkip),
971	DestructArray(DestructArray),
972	DestructObject(DestructObject),
973}
974
975#[derive(Debug, Clone, PartialEq, Eq, Hash)]
976pub enum DestructArrayPart {
977	DestructArrayElement(DestructArrayElement),
978	DestructRest(DestructRest),
979}
980
981#[derive(Debug, Clone, PartialEq, Eq, Hash)]
982pub struct BinaryOperator {
983	syntax: SyntaxToken,
984	kind: BinaryOperatorKind,
985}
986
987#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
988pub enum BinaryOperatorKind {
989	Or,
990	And,
991	BitOr,
992	BitXor,
993	BitAnd,
994	Eq,
995	Ne,
996	Lt,
997	Gt,
998	Le,
999	Ge,
1000	InKw,
1001	Lhs,
1002	Rhs,
1003	Plus,
1004	Minus,
1005	Mul,
1006	Div,
1007	Modulo,
1008	ErrorNoOperator,
1009}
1010
1011#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1012pub struct UnaryOperator {
1013	syntax: SyntaxToken,
1014	kind: UnaryOperatorKind,
1015}
1016
1017#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
1018pub enum UnaryOperatorKind {
1019	Minus,
1020	Not,
1021	BitNot,
1022}
1023
1024#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1025pub struct Literal {
1026	syntax: SyntaxToken,
1027	kind: LiteralKind,
1028}
1029
1030#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
1031pub enum LiteralKind {
1032	NullKw,
1033	TrueKw,
1034	FalseKw,
1035	SelfKw,
1036	Dollar,
1037	SuperKw,
1038}
1039
1040#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1041pub struct String {
1042	syntax: SyntaxToken,
1043	kind: StringKind,
1044}
1045
1046#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
1047pub enum StringKind {
1048	StringDouble,
1049	StringSingle,
1050	StringDoubleVerbatim,
1051	StringSingleVerbatim,
1052	StringBlock,
1053}
1054
1055#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1056pub struct Number {
1057	syntax: SyntaxToken,
1058	kind: NumberKind,
1059}
1060
1061#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
1062pub enum NumberKind {
1063	Float,
1064	MetaForceEnum,
1065}
1066
1067#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1068pub struct ImportKind {
1069	syntax: SyntaxToken,
1070	kind: ImportKindKind,
1071}
1072
1073#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
1074pub enum ImportKindKind {
1075	ImportstrKw,
1076	ImportbinKw,
1077	ImportKw,
1078}
1079
1080#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1081pub struct Visibility {
1082	syntax: SyntaxToken,
1083	kind: VisibilityKind,
1084}
1085
1086#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
1087pub enum VisibilityKind {
1088	Coloncoloncolon,
1089	Coloncolon,
1090	Colon,
1091}
732impl AstNode for SourceFile {1092impl AstNode for SourceFile {
733	fn can_cast(kind: SyntaxKind) -> bool { kind == SOURCE_FILE }1093	fn can_cast(kind: SyntaxKind) -> bool {
1094		kind == SOURCE_FILE
1095	}
734	fn cast(syntax: SyntaxNode) -> Option<Self> {1096	fn cast(syntax: SyntaxNode) -> Option<Self> {
735		if Self::can_cast(syntax.kind()) {1097		if Self::can_cast(syntax.kind()) {
736			Some(Self { syntax })1098			Some(Self { syntax })
737		} else {1099		} else {
738			None1100			None
739		}1101		}
740	}1102	}
741	fn syntax(&self) -> &SyntaxNode { &self.syntax }1103	fn syntax(&self) -> &SyntaxNode {
1104		&self.syntax
1105	}
742}1106}
743impl AstNode for ExprBinary {1107impl AstNode for ExprBinary {
744	fn can_cast(kind: SyntaxKind) -> bool { kind == EXPR_BINARY }1108	fn can_cast(kind: SyntaxKind) -> bool {
1109		kind == EXPR_BINARY
1110	}
745	fn cast(syntax: SyntaxNode) -> Option<Self> {1111	fn cast(syntax: SyntaxNode) -> Option<Self> {
746		if Self::can_cast(syntax.kind()) {1112		if Self::can_cast(syntax.kind()) {
747			Some(Self { syntax })1113			Some(Self { syntax })
748		} else {1114		} else {
749			None1115			None
750		}1116		}
751	}1117	}
752	fn syntax(&self) -> &SyntaxNode { &self.syntax }1118	fn syntax(&self) -> &SyntaxNode {
1119		&self.syntax
1120	}
753}1121}
754impl AstNode for BinaryOperator {1122impl AstNode for LhsExpr {
755	fn can_cast(kind: SyntaxKind) -> bool { kind == BINARY_OPERATOR }1123	fn can_cast(kind: SyntaxKind) -> bool {
1124		kind == LHS_EXPR
1125	}
756	fn cast(syntax: SyntaxNode) -> Option<Self> {1126	fn cast(syntax: SyntaxNode) -> Option<Self> {
757		if Self::can_cast(syntax.kind()) {1127		if Self::can_cast(syntax.kind()) {
758			Some(Self { syntax })1128			Some(Self { syntax })
759		} else {1129		} else {
760			None1130			None
761		}1131		}
762	}1132	}
763	fn syntax(&self) -> &SyntaxNode { &self.syntax }1133	fn syntax(&self) -> &SyntaxNode {
1134		&self.syntax
1135	}
764}1136}
765impl AstNode for ExprUnary {1137impl AstNode for ExprUnary {
766	fn can_cast(kind: SyntaxKind) -> bool { kind == EXPR_UNARY }1138	fn can_cast(kind: SyntaxKind) -> bool {
767	fn cast(syntax: SyntaxNode) -> Option<Self> {1139		kind == EXPR_UNARY
768		if Self::can_cast(syntax.kind()) {
769			Some(Self { syntax })
770		} else {
771			None
772		}
773	}1140	}
774	fn syntax(&self) -> &SyntaxNode { &self.syntax }
775}
776impl AstNode for UnaryOperator {
777	fn can_cast(kind: SyntaxKind) -> bool { kind == UNARY_OPERATOR }
778	fn cast(syntax: SyntaxNode) -> Option<Self> {1141	fn cast(syntax: SyntaxNode) -> Option<Self> {
779		if Self::can_cast(syntax.kind()) {1142		if Self::can_cast(syntax.kind()) {
780			Some(Self { syntax })1143			Some(Self { syntax })
781		} else {1144		} else {
782			None1145			None
783		}1146		}
784	}1147	}
785	fn syntax(&self) -> &SyntaxNode { &self.syntax }1148	fn syntax(&self) -> &SyntaxNode {
1149		&self.syntax
1150	}
786}1151}
787impl AstNode for ExprSlice {1152impl AstNode for ExprSlice {
788	fn can_cast(kind: SyntaxKind) -> bool { kind == EXPR_SLICE }1153	fn can_cast(kind: SyntaxKind) -> bool {
1154		kind == EXPR_SLICE
1155	}
789	fn cast(syntax: SyntaxNode) -> Option<Self> {1156	fn cast(syntax: SyntaxNode) -> Option<Self> {
790		if Self::can_cast(syntax.kind()) {1157		if Self::can_cast(syntax.kind()) {
791			Some(Self { syntax })1158			Some(Self { syntax })
792		} else {1159		} else {
793			None1160			None
794		}1161		}
795	}1162	}
796	fn syntax(&self) -> &SyntaxNode { &self.syntax }1163	fn syntax(&self) -> &SyntaxNode {
1164		&self.syntax
1165	}
797}1166}
798impl AstNode for SliceDesc {1167impl AstNode for SliceDesc {
799	fn can_cast(kind: SyntaxKind) -> bool { kind == SLICE_DESC }1168	fn can_cast(kind: SyntaxKind) -> bool {
1169		kind == SLICE_DESC
1170	}
800	fn cast(syntax: SyntaxNode) -> Option<Self> {1171	fn cast(syntax: SyntaxNode) -> Option<Self> {
801		if Self::can_cast(syntax.kind()) {1172		if Self::can_cast(syntax.kind()) {
802			Some(Self { syntax })1173			Some(Self { syntax })
803		} else {1174		} else {
804			None1175			None
805		}1176		}
806	}1177	}
807	fn syntax(&self) -> &SyntaxNode { &self.syntax }1178	fn syntax(&self) -> &SyntaxNode {
1179		&self.syntax
1180	}
808}1181}
809impl AstNode for ExprIndex {1182impl AstNode for ExprIndex {
810	fn can_cast(kind: SyntaxKind) -> bool { kind == EXPR_INDEX }1183	fn can_cast(kind: SyntaxKind) -> bool {
1184		kind == EXPR_INDEX
1185	}
811	fn cast(syntax: SyntaxNode) -> Option<Self> {1186	fn cast(syntax: SyntaxNode) -> Option<Self> {
812		if Self::can_cast(syntax.kind()) {1187		if Self::can_cast(syntax.kind()) {
813			Some(Self { syntax })1188			Some(Self { syntax })
814		} else {1189		} else {
815			None1190			None
816		}1191		}
817	}1192	}
818	fn syntax(&self) -> &SyntaxNode { &self.syntax }1193	fn syntax(&self) -> &SyntaxNode {
1194		&self.syntax
1195	}
819}1196}
820impl AstNode for Name {1197impl AstNode for Name {
821	fn can_cast(kind: SyntaxKind) -> bool { kind == NAME }1198	fn can_cast(kind: SyntaxKind) -> bool {
1199		kind == NAME
1200	}
822	fn cast(syntax: SyntaxNode) -> Option<Self> {1201	fn cast(syntax: SyntaxNode) -> Option<Self> {
823		if Self::can_cast(syntax.kind()) {1202		if Self::can_cast(syntax.kind()) {
824			Some(Self { syntax })1203			Some(Self { syntax })
825		} else {1204		} else {
826			None1205			None
827		}1206		}
828	}1207	}
829	fn syntax(&self) -> &SyntaxNode { &self.syntax }1208	fn syntax(&self) -> &SyntaxNode {
1209		&self.syntax
1210	}
830}1211}
831impl AstNode for ExprIndexExpr {1212impl AstNode for ExprIndexExpr {
832	fn can_cast(kind: SyntaxKind) -> bool { kind == EXPR_INDEX_EXPR }1213	fn can_cast(kind: SyntaxKind) -> bool {
1214		kind == EXPR_INDEX_EXPR
1215	}
833	fn cast(syntax: SyntaxNode) -> Option<Self> {1216	fn cast(syntax: SyntaxNode) -> Option<Self> {
834		if Self::can_cast(syntax.kind()) {1217		if Self::can_cast(syntax.kind()) {
835			Some(Self { syntax })1218			Some(Self { syntax })
836		} else {1219		} else {
837			None1220			None
838		}1221		}
839	}1222	}
840	fn syntax(&self) -> &SyntaxNode { &self.syntax }1223	fn syntax(&self) -> &SyntaxNode {
1224		&self.syntax
1225	}
841}1226}
842impl AstNode for ExprApply {1227impl AstNode for ExprApply {
843	fn can_cast(kind: SyntaxKind) -> bool { kind == EXPR_APPLY }1228	fn can_cast(kind: SyntaxKind) -> bool {
1229		kind == EXPR_APPLY
1230	}
844	fn cast(syntax: SyntaxNode) -> Option<Self> {1231	fn cast(syntax: SyntaxNode) -> Option<Self> {
845		if Self::can_cast(syntax.kind()) {1232		if Self::can_cast(syntax.kind()) {
846			Some(Self { syntax })1233			Some(Self { syntax })
847		} else {1234		} else {
848			None1235			None
849		}1236		}
850	}1237	}
851	fn syntax(&self) -> &SyntaxNode { &self.syntax }1238	fn syntax(&self) -> &SyntaxNode {
1239		&self.syntax
1240	}
852}1241}
853impl AstNode for ArgsDesc {1242impl AstNode for ArgsDesc {
854	fn can_cast(kind: SyntaxKind) -> bool { kind == ARGS_DESC }1243	fn can_cast(kind: SyntaxKind) -> bool {
1244		kind == ARGS_DESC
1245	}
855	fn cast(syntax: SyntaxNode) -> Option<Self> {1246	fn cast(syntax: SyntaxNode) -> Option<Self> {
856		if Self::can_cast(syntax.kind()) {1247		if Self::can_cast(syntax.kind()) {
857			Some(Self { syntax })1248			Some(Self { syntax })
858		} else {1249		} else {
859			None1250			None
860		}1251		}
861	}1252	}
862	fn syntax(&self) -> &SyntaxNode { &self.syntax }1253	fn syntax(&self) -> &SyntaxNode {
1254		&self.syntax
1255	}
863}1256}
864impl AstNode for ExprObjExtend {1257impl AstNode for ExprObjExtend {
865	fn can_cast(kind: SyntaxKind) -> bool { kind == EXPR_OBJ_EXTEND }1258	fn can_cast(kind: SyntaxKind) -> bool {
1259		kind == EXPR_OBJ_EXTEND
1260	}
866	fn cast(syntax: SyntaxNode) -> Option<Self> {1261	fn cast(syntax: SyntaxNode) -> Option<Self> {
867		if Self::can_cast(syntax.kind()) {1262		if Self::can_cast(syntax.kind()) {
868			Some(Self { syntax })1263			Some(Self { syntax })
869		} else {1264		} else {
870			None1265			None
871		}1266		}
872	}1267	}
873	fn syntax(&self) -> &SyntaxNode { &self.syntax }1268	fn syntax(&self) -> &SyntaxNode {
1269		&self.syntax
1270	}
874}1271}
875impl AstNode for ExprParened {1272impl AstNode for ExprParened {
876	fn can_cast(kind: SyntaxKind) -> bool { kind == EXPR_PARENED }1273	fn can_cast(kind: SyntaxKind) -> bool {
1274		kind == EXPR_PARENED
1275	}
877	fn cast(syntax: SyntaxNode) -> Option<Self> {1276	fn cast(syntax: SyntaxNode) -> Option<Self> {
878		if Self::can_cast(syntax.kind()) {1277		if Self::can_cast(syntax.kind()) {
879			Some(Self { syntax })1278			Some(Self { syntax })
880		} else {1279		} else {
881			None1280			None
882		}1281		}
883	}1282	}
884	fn syntax(&self) -> &SyntaxNode { &self.syntax }1283	fn syntax(&self) -> &SyntaxNode {
1284		&self.syntax
1285	}
885}1286}
886impl AstNode for ExprLiteral {1287impl AstNode for ExprLiteral {
887	fn can_cast(kind: SyntaxKind) -> bool { kind == EXPR_LITERAL }1288	fn can_cast(kind: SyntaxKind) -> bool {
1289		kind == EXPR_LITERAL
1290	}
888	fn cast(syntax: SyntaxNode) -> Option<Self> {1291	fn cast(syntax: SyntaxNode) -> Option<Self> {
889		if Self::can_cast(syntax.kind()) {1292		if Self::can_cast(syntax.kind()) {
890			Some(Self { syntax })1293			Some(Self { syntax })
891		} else {1294		} else {
892			None1295			None
893		}1296		}
894	}1297	}
895	fn syntax(&self) -> &SyntaxNode { &self.syntax }1298	fn syntax(&self) -> &SyntaxNode {
1299		&self.syntax
1300	}
896}1301}
897impl AstNode for Literal {1302impl AstNode for ExprIntrinsicThisFile {
898	fn can_cast(kind: SyntaxKind) -> bool { kind == LITERAL }1303	fn can_cast(kind: SyntaxKind) -> bool {
1304		kind == EXPR_INTRINSIC_THIS_FILE
1305	}
899	fn cast(syntax: SyntaxNode) -> Option<Self> {1306	fn cast(syntax: SyntaxNode) -> Option<Self> {
900		if Self::can_cast(syntax.kind()) {1307		if Self::can_cast(syntax.kind()) {
901			Some(Self { syntax })1308			Some(Self { syntax })
902		} else {1309		} else {
903			None1310			None
904		}1311		}
905	}1312	}
906	fn syntax(&self) -> &SyntaxNode { &self.syntax }1313	fn syntax(&self) -> &SyntaxNode {
1314		&self.syntax
1315	}
907}1316}
908impl AstNode for ExprIntrinsicThisFile {1317impl AstNode for ExprIntrinsicId {
909	fn can_cast(kind: SyntaxKind) -> bool { kind == EXPR_INTRINSIC_THIS_FILE }1318	fn can_cast(kind: SyntaxKind) -> bool {
1319		kind == EXPR_INTRINSIC_ID
1320	}
910	fn cast(syntax: SyntaxNode) -> Option<Self> {1321	fn cast(syntax: SyntaxNode) -> Option<Self> {
911		if Self::can_cast(syntax.kind()) {1322		if Self::can_cast(syntax.kind()) {
912			Some(Self { syntax })1323			Some(Self { syntax })
913		} else {1324		} else {
914			None1325			None
915		}1326		}
916	}1327	}
917	fn syntax(&self) -> &SyntaxNode { &self.syntax }1328	fn syntax(&self) -> &SyntaxNode {
1329		&self.syntax
1330	}
918}1331}
919impl AstNode for ExprIntrinsicId {1332impl AstNode for ExprIntrinsic {
920	fn can_cast(kind: SyntaxKind) -> bool { kind == EXPR_INTRINSIC_ID }1333	fn can_cast(kind: SyntaxKind) -> bool {
1334		kind == EXPR_INTRINSIC
1335	}
921	fn cast(syntax: SyntaxNode) -> Option<Self> {1336	fn cast(syntax: SyntaxNode) -> Option<Self> {
922		if Self::can_cast(syntax.kind()) {1337		if Self::can_cast(syntax.kind()) {
923			Some(Self { syntax })1338			Some(Self { syntax })
924		} else {1339		} else {
925			None1340			None
926		}1341		}
927	}1342	}
928	fn syntax(&self) -> &SyntaxNode { &self.syntax }1343	fn syntax(&self) -> &SyntaxNode {
1344		&self.syntax
1345	}
929}1346}
930impl AstNode for ExprIntrinsic {1347impl AstNode for ExprString {
931	fn can_cast(kind: SyntaxKind) -> bool { kind == EXPR_INTRINSIC }1348	fn can_cast(kind: SyntaxKind) -> bool {
1349		kind == EXPR_STRING
1350	}
932	fn cast(syntax: SyntaxNode) -> Option<Self> {1351	fn cast(syntax: SyntaxNode) -> Option<Self> {
933		if Self::can_cast(syntax.kind()) {1352		if Self::can_cast(syntax.kind()) {
934			Some(Self { syntax })1353			Some(Self { syntax })
935		} else {1354		} else {
936			None1355			None
937		}1356		}
938	}1357	}
939	fn syntax(&self) -> &SyntaxNode { &self.syntax }1358	fn syntax(&self) -> &SyntaxNode {
1359		&self.syntax
1360	}
940}1361}
941impl AstNode for ExprString {1362impl AstNode for ExprNumber {
942	fn can_cast(kind: SyntaxKind) -> bool { kind == EXPR_STRING }1363	fn can_cast(kind: SyntaxKind) -> bool {
1364		kind == EXPR_NUMBER
1365	}
943	fn cast(syntax: SyntaxNode) -> Option<Self> {1366	fn cast(syntax: SyntaxNode) -> Option<Self> {
944		if Self::can_cast(syntax.kind()) {1367		if Self::can_cast(syntax.kind()) {
945			Some(Self { syntax })1368			Some(Self { syntax })
946		} else {1369		} else {
947			None1370			None
948		}1371		}
949	}1372	}
950	fn syntax(&self) -> &SyntaxNode { &self.syntax }1373	fn syntax(&self) -> &SyntaxNode {
1374		&self.syntax
1375	}
951}1376}
952impl AstNode for String {1377impl AstNode for ExprArray {
953	fn can_cast(kind: SyntaxKind) -> bool { kind == STRING }1378	fn can_cast(kind: SyntaxKind) -> bool {
1379		kind == EXPR_ARRAY
1380	}
954	fn cast(syntax: SyntaxNode) -> Option<Self> {1381	fn cast(syntax: SyntaxNode) -> Option<Self> {
955		if Self::can_cast(syntax.kind()) {1382		if Self::can_cast(syntax.kind()) {
956			Some(Self { syntax })1383			Some(Self { syntax })
957		} else {1384		} else {
958			None1385			None
959		}1386		}
960	}1387	}
961	fn syntax(&self) -> &SyntaxNode { &self.syntax }1388	fn syntax(&self) -> &SyntaxNode {
1389		&self.syntax
1390	}
962}1391}
963impl AstNode for ExprNumber {1392impl AstNode for ExprObject {
964	fn can_cast(kind: SyntaxKind) -> bool { kind == EXPR_NUMBER }1393	fn can_cast(kind: SyntaxKind) -> bool {
1394		kind == EXPR_OBJECT
1395	}
965	fn cast(syntax: SyntaxNode) -> Option<Self> {1396	fn cast(syntax: SyntaxNode) -> Option<Self> {
966		if Self::can_cast(syntax.kind()) {1397		if Self::can_cast(syntax.kind()) {
967			Some(Self { syntax })1398			Some(Self { syntax })
968		} else {1399		} else {
969			None1400			None
970		}1401		}
971	}1402	}
972	fn syntax(&self) -> &SyntaxNode { &self.syntax }1403	fn syntax(&self) -> &SyntaxNode {
1404		&self.syntax
1405	}
973}1406}
974impl AstNode for Number {1407impl AstNode for ExprArrayComp {
975	fn can_cast(kind: SyntaxKind) -> bool { kind == NUMBER }1408	fn can_cast(kind: SyntaxKind) -> bool {
1409		kind == EXPR_ARRAY_COMP
1410	}
976	fn cast(syntax: SyntaxNode) -> Option<Self> {1411	fn cast(syntax: SyntaxNode) -> Option<Self> {
977		if Self::can_cast(syntax.kind()) {1412		if Self::can_cast(syntax.kind()) {
978			Some(Self { syntax })1413			Some(Self { syntax })
979		} else {1414		} else {
980			None1415			None
981		}1416		}
982	}1417	}
983	fn syntax(&self) -> &SyntaxNode { &self.syntax }1418	fn syntax(&self) -> &SyntaxNode {
1419		&self.syntax
1420	}
984}1421}
985impl AstNode for ExprArray {1422impl AstNode for ExprImport {
986	fn can_cast(kind: SyntaxKind) -> bool { kind == EXPR_ARRAY }1423	fn can_cast(kind: SyntaxKind) -> bool {
1424		kind == EXPR_IMPORT
1425	}
987	fn cast(syntax: SyntaxNode) -> Option<Self> {1426	fn cast(syntax: SyntaxNode) -> Option<Self> {
988		if Self::can_cast(syntax.kind()) {1427		if Self::can_cast(syntax.kind()) {
989			Some(Self { syntax })1428			Some(Self { syntax })
990		} else {1429		} else {
991			None1430			None
992		}1431		}
993	}1432	}
994	fn syntax(&self) -> &SyntaxNode { &self.syntax }1433	fn syntax(&self) -> &SyntaxNode {
1434		&self.syntax
1435	}
995}1436}
996impl AstNode for ExprObject {1437impl AstNode for ExprVar {
997	fn can_cast(kind: SyntaxKind) -> bool { kind == EXPR_OBJECT }1438	fn can_cast(kind: SyntaxKind) -> bool {
1439		kind == EXPR_VAR
1440	}
998	fn cast(syntax: SyntaxNode) -> Option<Self> {1441	fn cast(syntax: SyntaxNode) -> Option<Self> {
999		if Self::can_cast(syntax.kind()) {1442		if Self::can_cast(syntax.kind()) {
1000			Some(Self { syntax })1443			Some(Self { syntax })
1001		} else {1444		} else {
1002			None1445			None
1003		}1446		}
1004	}1447	}
1005	fn syntax(&self) -> &SyntaxNode { &self.syntax }1448	fn syntax(&self) -> &SyntaxNode {
1449		&self.syntax
1450	}
1006}1451}
1007impl AstNode for ExprArrayComp {1452impl AstNode for ExprLocal {
1008	fn can_cast(kind: SyntaxKind) -> bool { kind == EXPR_ARRAY_COMP }1453	fn can_cast(kind: SyntaxKind) -> bool {
1454		kind == EXPR_LOCAL
1455	}
1009	fn cast(syntax: SyntaxNode) -> Option<Self> {1456	fn cast(syntax: SyntaxNode) -> Option<Self> {
1010		if Self::can_cast(syntax.kind()) {1457		if Self::can_cast(syntax.kind()) {
1011			Some(Self { syntax })1458			Some(Self { syntax })
1012		} else {1459		} else {
1013			None1460			None
1014		}1461		}
1015	}1462	}
1016	fn syntax(&self) -> &SyntaxNode { &self.syntax }1463	fn syntax(&self) -> &SyntaxNode {
1464		&self.syntax
1465	}
1017}1466}
1018impl AstNode for ForSpec {1467impl AstNode for ExprIfThenElse {
1019	fn can_cast(kind: SyntaxKind) -> bool { kind == FOR_SPEC }1468	fn can_cast(kind: SyntaxKind) -> bool {
1469		kind == EXPR_IF_THEN_ELSE
1470	}
1020	fn cast(syntax: SyntaxNode) -> Option<Self> {1471	fn cast(syntax: SyntaxNode) -> Option<Self> {
1021		if Self::can_cast(syntax.kind()) {1472		if Self::can_cast(syntax.kind()) {
1022			Some(Self { syntax })1473			Some(Self { syntax })
1023		} else {1474		} else {
1024			None1475			None
1025		}1476		}
1026	}1477	}
1027	fn syntax(&self) -> &SyntaxNode { &self.syntax }1478	fn syntax(&self) -> &SyntaxNode {
1479		&self.syntax
1480	}
1028}1481}
1029impl AstNode for ExprImport {1482impl AstNode for TrueExpr {
1030	fn can_cast(kind: SyntaxKind) -> bool { kind == EXPR_IMPORT }1483	fn can_cast(kind: SyntaxKind) -> bool {
1484		kind == TRUE_EXPR
1485	}
1031	fn cast(syntax: SyntaxNode) -> Option<Self> {1486	fn cast(syntax: SyntaxNode) -> Option<Self> {
1032		if Self::can_cast(syntax.kind()) {1487		if Self::can_cast(syntax.kind()) {
1033			Some(Self { syntax })1488			Some(Self { syntax })
1034		} else {1489		} else {
1035			None1490			None
1036		}1491		}
1037	}1492	}
1038	fn syntax(&self) -> &SyntaxNode { &self.syntax }1493	fn syntax(&self) -> &SyntaxNode {
1494		&self.syntax
1495	}
1039}1496}
1040impl AstNode for ExprVar {1497impl AstNode for FalseExpr {
1041	fn can_cast(kind: SyntaxKind) -> bool { kind == EXPR_VAR }1498	fn can_cast(kind: SyntaxKind) -> bool {
1499		kind == FALSE_EXPR
1500	}
1042	fn cast(syntax: SyntaxNode) -> Option<Self> {1501	fn cast(syntax: SyntaxNode) -> Option<Self> {
1043		if Self::can_cast(syntax.kind()) {1502		if Self::can_cast(syntax.kind()) {
1044			Some(Self { syntax })1503			Some(Self { syntax })
1045		} else {1504		} else {
1046			None1505			None
1047		}1506		}
1048	}1507	}
1049	fn syntax(&self) -> &SyntaxNode { &self.syntax }1508	fn syntax(&self) -> &SyntaxNode {
1509		&self.syntax
1510	}
1050}1511}
1051impl AstNode for ExprLocal {1512impl AstNode for ExprFunction {
1052	fn can_cast(kind: SyntaxKind) -> bool { kind == EXPR_LOCAL }1513	fn can_cast(kind: SyntaxKind) -> bool {
1514		kind == EXPR_FUNCTION
1515	}
1053	fn cast(syntax: SyntaxNode) -> Option<Self> {1516	fn cast(syntax: SyntaxNode) -> Option<Self> {
1054		if Self::can_cast(syntax.kind()) {1517		if Self::can_cast(syntax.kind()) {
1055			Some(Self { syntax })1518			Some(Self { syntax })
1056		} else {1519		} else {
1057			None1520			None
1058		}1521		}
1059	}1522	}
1060	fn syntax(&self) -> &SyntaxNode { &self.syntax }1523	fn syntax(&self) -> &SyntaxNode {
1524		&self.syntax
1525	}
1061}1526}
1062impl AstNode for ExprIfThenElse {1527impl AstNode for ParamsDesc {
1063	fn can_cast(kind: SyntaxKind) -> bool { kind == EXPR_IF_THEN_ELSE }1528	fn can_cast(kind: SyntaxKind) -> bool {
1529		kind == PARAMS_DESC
1530	}
1064	fn cast(syntax: SyntaxNode) -> Option<Self> {1531	fn cast(syntax: SyntaxNode) -> Option<Self> {
1065		if Self::can_cast(syntax.kind()) {1532		if Self::can_cast(syntax.kind()) {
1066			Some(Self { syntax })1533			Some(Self { syntax })
1067		} else {1534		} else {
1068			None1535			None
1069		}1536		}
1070	}1537	}
1071	fn syntax(&self) -> &SyntaxNode { &self.syntax }1538	fn syntax(&self) -> &SyntaxNode {
1539		&self.syntax
1540	}
1072}1541}
1073impl AstNode for ExprFunction {1542impl AstNode for ExprAssert {
1074	fn can_cast(kind: SyntaxKind) -> bool { kind == EXPR_FUNCTION }1543	fn can_cast(kind: SyntaxKind) -> bool {
1544		kind == EXPR_ASSERT
1545	}
1075	fn cast(syntax: SyntaxNode) -> Option<Self> {1546	fn cast(syntax: SyntaxNode) -> Option<Self> {
1076		if Self::can_cast(syntax.kind()) {1547		if Self::can_cast(syntax.kind()) {
1077			Some(Self { syntax })1548			Some(Self { syntax })
1078		} else {1549		} else {
1079			None1550			None
1080		}1551		}
1081	}1552	}
1082	fn syntax(&self) -> &SyntaxNode { &self.syntax }1553	fn syntax(&self) -> &SyntaxNode {
1554		&self.syntax
1555	}
1083}1556}
1084impl AstNode for ParamsDesc {1557impl AstNode for Assertion {
1085	fn can_cast(kind: SyntaxKind) -> bool { kind == PARAMS_DESC }1558	fn can_cast(kind: SyntaxKind) -> bool {
1559		kind == ASSERTION
1560	}
1086	fn cast(syntax: SyntaxNode) -> Option<Self> {1561	fn cast(syntax: SyntaxNode) -> Option<Self> {
1087		if Self::can_cast(syntax.kind()) {1562		if Self::can_cast(syntax.kind()) {
1088			Some(Self { syntax })1563			Some(Self { syntax })
1089		} else {1564		} else {
1090			None1565			None
1091		}1566		}
1092	}1567	}
1093	fn syntax(&self) -> &SyntaxNode { &self.syntax }1568	fn syntax(&self) -> &SyntaxNode {
1569		&self.syntax
1570	}
1094}1571}
1095impl AstNode for ExprAssert {1572impl AstNode for ExprError {
1096	fn can_cast(kind: SyntaxKind) -> bool { kind == EXPR_ASSERT }1573	fn can_cast(kind: SyntaxKind) -> bool {
1574		kind == EXPR_ERROR
1575	}
1097	fn cast(syntax: SyntaxNode) -> Option<Self> {1576	fn cast(syntax: SyntaxNode) -> Option<Self> {
1098		if Self::can_cast(syntax.kind()) {1577		if Self::can_cast(syntax.kind()) {
1099			Some(Self { syntax })1578			Some(Self { syntax })
1100		} else {1579		} else {
1101			None1580			None
1102		}1581		}
1103	}1582	}
1104	fn syntax(&self) -> &SyntaxNode { &self.syntax }1583	fn syntax(&self) -> &SyntaxNode {
1584		&self.syntax
1585	}
1105}1586}
1106impl AstNode for Assertion {1587impl AstNode for SliceDescEnd {
1107	fn can_cast(kind: SyntaxKind) -> bool { kind == ASSERTION }1588	fn can_cast(kind: SyntaxKind) -> bool {
1589		kind == SLICE_DESC_END
1590	}
1108	fn cast(syntax: SyntaxNode) -> Option<Self> {1591	fn cast(syntax: SyntaxNode) -> Option<Self> {
1109		if Self::can_cast(syntax.kind()) {1592		if Self::can_cast(syntax.kind()) {
1110			Some(Self { syntax })1593			Some(Self { syntax })
1111		} else {1594		} else {
1112			None1595			None
1113		}1596		}
1114	}1597	}
1115	fn syntax(&self) -> &SyntaxNode { &self.syntax }1598	fn syntax(&self) -> &SyntaxNode {
1599		&self.syntax
1600	}
1116}1601}
1117impl AstNode for ExprError {1602impl AstNode for SliceDescStep {
1118	fn can_cast(kind: SyntaxKind) -> bool { kind == EXPR_ERROR }1603	fn can_cast(kind: SyntaxKind) -> bool {
1604		kind == SLICE_DESC_STEP
1605	}
1119	fn cast(syntax: SyntaxNode) -> Option<Self> {1606	fn cast(syntax: SyntaxNode) -> Option<Self> {
1120		if Self::can_cast(syntax.kind()) {1607		if Self::can_cast(syntax.kind()) {
1121			Some(Self { syntax })1608			Some(Self { syntax })
1122		} else {1609		} else {
1123			None1610			None
1124		}1611		}
1125	}1612	}
1126	fn syntax(&self) -> &SyntaxNode { &self.syntax }1613	fn syntax(&self) -> &SyntaxNode {
1614		&self.syntax
1615	}
1127}1616}
1128impl AstNode for Arg {1617impl AstNode for Arg {
1129	fn can_cast(kind: SyntaxKind) -> bool { kind == ARG }1618	fn can_cast(kind: SyntaxKind) -> bool {
1619		kind == ARG
1620	}
1130	fn cast(syntax: SyntaxNode) -> Option<Self> {1621	fn cast(syntax: SyntaxNode) -> Option<Self> {
1131		if Self::can_cast(syntax.kind()) {1622		if Self::can_cast(syntax.kind()) {
1132			Some(Self { syntax })1623			Some(Self { syntax })
1133		} else {1624		} else {
1134			None1625			None
1135		}1626		}
1136	}1627	}
1137	fn syntax(&self) -> &SyntaxNode { &self.syntax }1628	fn syntax(&self) -> &SyntaxNode {
1629		&self.syntax
1630	}
1138}1631}
1139impl AstNode for ObjBodyComp {1632impl AstNode for ObjBodyComp {
1140	fn can_cast(kind: SyntaxKind) -> bool { kind == OBJ_BODY_COMP }1633	fn can_cast(kind: SyntaxKind) -> bool {
1634		kind == OBJ_BODY_COMP
1635	}
1141	fn cast(syntax: SyntaxNode) -> Option<Self> {1636	fn cast(syntax: SyntaxNode) -> Option<Self> {
1142		if Self::can_cast(syntax.kind()) {1637		if Self::can_cast(syntax.kind()) {
1143			Some(Self { syntax })1638			Some(Self { syntax })
1144		} else {1639		} else {
1145			None1640			None
1146		}1641		}
1147	}1642	}
1148	fn syntax(&self) -> &SyntaxNode { &self.syntax }1643	fn syntax(&self) -> &SyntaxNode {
1644		&self.syntax
1645	}
1149}1646}
1150impl AstNode for ObjLocalPostComma {1647impl AstNode for ObjLocalPostComma {
1151	fn can_cast(kind: SyntaxKind) -> bool { kind == OBJ_LOCAL_POST_COMMA }1648	fn can_cast(kind: SyntaxKind) -> bool {
1649		kind == OBJ_LOCAL_POST_COMMA
1650	}
1152	fn cast(syntax: SyntaxNode) -> Option<Self> {1651	fn cast(syntax: SyntaxNode) -> Option<Self> {
1153		if Self::can_cast(syntax.kind()) {1652		if Self::can_cast(syntax.kind()) {
1154			Some(Self { syntax })1653			Some(Self { syntax })
1155		} else {1654		} else {
1156			None1655			None
1157		}1656		}
1158	}1657	}
1159	fn syntax(&self) -> &SyntaxNode { &self.syntax }1658	fn syntax(&self) -> &SyntaxNode {
1659		&self.syntax
1660	}
1160}1661}
1161impl AstNode for ObjLocalPreComma {1662impl AstNode for ObjLocalPreComma {
1162	fn can_cast(kind: SyntaxKind) -> bool { kind == OBJ_LOCAL_PRE_COMMA }1663	fn can_cast(kind: SyntaxKind) -> bool {
1664		kind == OBJ_LOCAL_PRE_COMMA
1665	}
1163	fn cast(syntax: SyntaxNode) -> Option<Self> {1666	fn cast(syntax: SyntaxNode) -> Option<Self> {
1164		if Self::can_cast(syntax.kind()) {1667		if Self::can_cast(syntax.kind()) {
1165			Some(Self { syntax })1668			Some(Self { syntax })
1166		} else {1669		} else {
1167			None1670			None
1168		}1671		}
1169	}1672	}
1170	fn syntax(&self) -> &SyntaxNode { &self.syntax }1673	fn syntax(&self) -> &SyntaxNode {
1674		&self.syntax
1675	}
1171}1676}
1172impl AstNode for ObjBodyMemberList {1677impl AstNode for ObjBodyMemberList {
1173	fn can_cast(kind: SyntaxKind) -> bool { kind == OBJ_BODY_MEMBER_LIST }1678	fn can_cast(kind: SyntaxKind) -> bool {
1679		kind == OBJ_BODY_MEMBER_LIST
1680	}
1174	fn cast(syntax: SyntaxNode) -> Option<Self> {1681	fn cast(syntax: SyntaxNode) -> Option<Self> {
1175		if Self::can_cast(syntax.kind()) {1682		if Self::can_cast(syntax.kind()) {
1176			Some(Self { syntax })1683			Some(Self { syntax })
1177		} else {1684		} else {
1178			None1685			None
1179		}1686		}
1180	}1687	}
1181	fn syntax(&self) -> &SyntaxNode { &self.syntax }1688	fn syntax(&self) -> &SyntaxNode {
1689		&self.syntax
1690	}
1182}1691}
1183impl AstNode for ObjLocal {1692impl AstNode for ObjLocal {
1184	fn can_cast(kind: SyntaxKind) -> bool { kind == OBJ_LOCAL }1693	fn can_cast(kind: SyntaxKind) -> bool {
1694		kind == OBJ_LOCAL
1695	}
1185	fn cast(syntax: SyntaxNode) -> Option<Self> {1696	fn cast(syntax: SyntaxNode) -> Option<Self> {
1186		if Self::can_cast(syntax.kind()) {1697		if Self::can_cast(syntax.kind()) {
1187			Some(Self { syntax })1698			Some(Self { syntax })
1188		} else {1699		} else {
1189			None1700			None
1190		}1701		}
1191	}1702	}
1192	fn syntax(&self) -> &SyntaxNode { &self.syntax }1703	fn syntax(&self) -> &SyntaxNode {
1704		&self.syntax
1705	}
1193}1706}
1194impl AstNode for MemberBindStmt {1707impl AstNode for MemberBindStmt {
1195	fn can_cast(kind: SyntaxKind) -> bool { kind == MEMBER_BIND_STMT }1708	fn can_cast(kind: SyntaxKind) -> bool {
1709		kind == MEMBER_BIND_STMT
1710	}
1196	fn cast(syntax: SyntaxNode) -> Option<Self> {1711	fn cast(syntax: SyntaxNode) -> Option<Self> {
1197		if Self::can_cast(syntax.kind()) {1712		if Self::can_cast(syntax.kind()) {
1198			Some(Self { syntax })1713			Some(Self { syntax })
1199		} else {1714		} else {
1200			None1715			None
1201		}1716		}
1202	}1717	}
1203	fn syntax(&self) -> &SyntaxNode { &self.syntax }1718	fn syntax(&self) -> &SyntaxNode {
1719		&self.syntax
1720	}
1204}1721}
1205impl AstNode for MemberAssertStmt {1722impl AstNode for MemberAssertStmt {
1206	fn can_cast(kind: SyntaxKind) -> bool { kind == MEMBER_ASSERT_STMT }1723	fn can_cast(kind: SyntaxKind) -> bool {
1724		kind == MEMBER_ASSERT_STMT
1725	}
1207	fn cast(syntax: SyntaxNode) -> Option<Self> {1726	fn cast(syntax: SyntaxNode) -> Option<Self> {
1208		if Self::can_cast(syntax.kind()) {1727		if Self::can_cast(syntax.kind()) {
1209			Some(Self { syntax })1728			Some(Self { syntax })
1210		} else {1729		} else {
1211			None1730			None
1212		}1731		}
1213	}1732	}
1214	fn syntax(&self) -> &SyntaxNode { &self.syntax }1733	fn syntax(&self) -> &SyntaxNode {
1734		&self.syntax
1735	}
1215}1736}
1216impl AstNode for MemberField {1737impl AstNode for MemberField {
1217	fn can_cast(kind: SyntaxKind) -> bool { kind == MEMBER_FIELD }1738	fn can_cast(kind: SyntaxKind) -> bool {
1739		kind == MEMBER_FIELD
1740	}
1218	fn cast(syntax: SyntaxNode) -> Option<Self> {1741	fn cast(syntax: SyntaxNode) -> Option<Self> {
1219		if Self::can_cast(syntax.kind()) {1742		if Self::can_cast(syntax.kind()) {
1220			Some(Self { syntax })1743			Some(Self { syntax })
1221		} else {1744		} else {
1222			None1745			None
1223		}1746		}
1224	}1747	}
1225	fn syntax(&self) -> &SyntaxNode { &self.syntax }1748	fn syntax(&self) -> &SyntaxNode {
1749		&self.syntax
1750	}
1226}1751}
1227impl AstNode for FieldNormal {1752impl AstNode for FieldNormal {
1228	fn can_cast(kind: SyntaxKind) -> bool { kind == FIELD_NORMAL }1753	fn can_cast(kind: SyntaxKind) -> bool {
1754		kind == FIELD_NORMAL
1755	}
1229	fn cast(syntax: SyntaxNode) -> Option<Self> {1756	fn cast(syntax: SyntaxNode) -> Option<Self> {
1230		if Self::can_cast(syntax.kind()) {1757		if Self::can_cast(syntax.kind()) {
1231			Some(Self { syntax })1758			Some(Self { syntax })
1232		} else {1759		} else {
1233			None1760			None
1234		}1761		}
1235	}1762	}
1236	fn syntax(&self) -> &SyntaxNode { &self.syntax }1763	fn syntax(&self) -> &SyntaxNode {
1764		&self.syntax
1765	}
1237}1766}
1238impl AstNode for Visibility {1767impl AstNode for FieldMethod {
1239	fn can_cast(kind: SyntaxKind) -> bool { kind == VISIBILITY }1768	fn can_cast(kind: SyntaxKind) -> bool {
1769		kind == FIELD_METHOD
1770	}
1240	fn cast(syntax: SyntaxNode) -> Option<Self> {1771	fn cast(syntax: SyntaxNode) -> Option<Self> {
1241		if Self::can_cast(syntax.kind()) {1772		if Self::can_cast(syntax.kind()) {
1242			Some(Self { syntax })1773			Some(Self { syntax })
1243		} else {1774		} else {
1244			None1775			None
1245		}1776		}
1246	}1777	}
1247	fn syntax(&self) -> &SyntaxNode { &self.syntax }1778	fn syntax(&self) -> &SyntaxNode {
1779		&self.syntax
1780	}
1248}1781}
1249impl AstNode for FieldMethod {1782impl AstNode for FieldNameFixed {
1250	fn can_cast(kind: SyntaxKind) -> bool { kind == FIELD_METHOD }1783	fn can_cast(kind: SyntaxKind) -> bool {
1784		kind == FIELD_NAME_FIXED
1785	}
1251	fn cast(syntax: SyntaxNode) -> Option<Self> {1786	fn cast(syntax: SyntaxNode) -> Option<Self> {
1252		if Self::can_cast(syntax.kind()) {1787		if Self::can_cast(syntax.kind()) {
1253			Some(Self { syntax })1788			Some(Self { syntax })
1254		} else {1789		} else {
1255			None1790			None
1256		}1791		}
1257	}1792	}
1258	fn syntax(&self) -> &SyntaxNode { &self.syntax }1793	fn syntax(&self) -> &SyntaxNode {
1794		&self.syntax
1795	}
1259}1796}
1260impl AstNode for FieldNameFixed {1797impl AstNode for FieldNameDynamic {
1261	fn can_cast(kind: SyntaxKind) -> bool { kind == FIELD_NAME_FIXED }1798	fn can_cast(kind: SyntaxKind) -> bool {
1799		kind == FIELD_NAME_DYNAMIC
1800	}
1262	fn cast(syntax: SyntaxNode) -> Option<Self> {1801	fn cast(syntax: SyntaxNode) -> Option<Self> {
1263		if Self::can_cast(syntax.kind()) {1802		if Self::can_cast(syntax.kind()) {
1264			Some(Self { syntax })1803			Some(Self { syntax })
1265		} else {1804		} else {
1266			None1805			None
1267		}1806		}
1268	}1807	}
1269	fn syntax(&self) -> &SyntaxNode { &self.syntax }1808	fn syntax(&self) -> &SyntaxNode {
1809		&self.syntax
1810	}
1270}1811}
1271impl AstNode for FieldNameDynamic {1812impl AstNode for ForSpec {
1272	fn can_cast(kind: SyntaxKind) -> bool { kind == FIELD_NAME_DYNAMIC }1813	fn can_cast(kind: SyntaxKind) -> bool {
1814		kind == FOR_SPEC
1815	}
1273	fn cast(syntax: SyntaxNode) -> Option<Self> {1816	fn cast(syntax: SyntaxNode) -> Option<Self> {
1274		if Self::can_cast(syntax.kind()) {1817		if Self::can_cast(syntax.kind()) {
1275			Some(Self { syntax })1818			Some(Self { syntax })
1276		} else {1819		} else {
1277			None1820			None
1278		}1821		}
1279	}1822	}
1280	fn syntax(&self) -> &SyntaxNode { &self.syntax }1823	fn syntax(&self) -> &SyntaxNode {
1824		&self.syntax
1825	}
1281}1826}
1282impl AstNode for IfSpec {1827impl AstNode for IfSpec {
1283	fn can_cast(kind: SyntaxKind) -> bool { kind == IF_SPEC }1828	fn can_cast(kind: SyntaxKind) -> bool {
1829		kind == IF_SPEC
1830	}
1284	fn cast(syntax: SyntaxNode) -> Option<Self> {1831	fn cast(syntax: SyntaxNode) -> Option<Self> {
1285		if Self::can_cast(syntax.kind()) {1832		if Self::can_cast(syntax.kind()) {
1286			Some(Self { syntax })1833			Some(Self { syntax })
1287		} else {1834		} else {
1288			None1835			None
1289		}1836		}
1290	}1837	}
1291	fn syntax(&self) -> &SyntaxNode { &self.syntax }1838	fn syntax(&self) -> &SyntaxNode {
1839		&self.syntax
1840	}
1292}1841}
1293impl AstNode for BindDestruct {1842impl AstNode for BindDestruct {
1294	fn can_cast(kind: SyntaxKind) -> bool { kind == BIND_DESTRUCT }1843	fn can_cast(kind: SyntaxKind) -> bool {
1844		kind == BIND_DESTRUCT
1845	}
1295	fn cast(syntax: SyntaxNode) -> Option<Self> {1846	fn cast(syntax: SyntaxNode) -> Option<Self> {
1296		if Self::can_cast(syntax.kind()) {1847		if Self::can_cast(syntax.kind()) {
1297			Some(Self { syntax })1848			Some(Self { syntax })
1298		} else {1849		} else {
1299			None1850			None
1300		}1851		}
1301	}1852	}
1302	fn syntax(&self) -> &SyntaxNode { &self.syntax }1853	fn syntax(&self) -> &SyntaxNode {
1854		&self.syntax
1855	}
1303}1856}
1304impl AstNode for Destruct {1857impl AstNode for BindFunction {
1305	fn can_cast(kind: SyntaxKind) -> bool { kind == DESTRUCT }1858	fn can_cast(kind: SyntaxKind) -> bool {
1859		kind == BIND_FUNCTION
1860	}
1306	fn cast(syntax: SyntaxNode) -> Option<Self> {1861	fn cast(syntax: SyntaxNode) -> Option<Self> {
1307		if Self::can_cast(syntax.kind()) {1862		if Self::can_cast(syntax.kind()) {
1308			Some(Self { syntax })1863			Some(Self { syntax })
1309		} else {1864		} else {
1310			None1865			None
1311		}1866		}
1312	}1867	}
1313	fn syntax(&self) -> &SyntaxNode { &self.syntax }1868	fn syntax(&self) -> &SyntaxNode {
1869		&self.syntax
1870	}
1314}1871}
1315impl AstNode for BindFunction {1872impl AstNode for Param {
1316	fn can_cast(kind: SyntaxKind) -> bool { kind == BIND_FUNCTION }1873	fn can_cast(kind: SyntaxKind) -> bool {
1874		kind == PARAM
1875	}
1317	fn cast(syntax: SyntaxNode) -> Option<Self> {1876	fn cast(syntax: SyntaxNode) -> Option<Self> {
1318		if Self::can_cast(syntax.kind()) {1877		if Self::can_cast(syntax.kind()) {
1319			Some(Self { syntax })1878			Some(Self { syntax })
1320		} else {1879		} else {
1321			None1880			None
1322		}1881		}
1323	}1882	}
1324	fn syntax(&self) -> &SyntaxNode { &self.syntax }1883	fn syntax(&self) -> &SyntaxNode {
1884		&self.syntax
1885	}
1325}1886}
1326impl AstNode for Param {1887impl AstNode for DestructFull {
1327	fn can_cast(kind: SyntaxKind) -> bool { kind == PARAM }1888	fn can_cast(kind: SyntaxKind) -> bool {
1889		kind == DESTRUCT_FULL
1890	}
1328	fn cast(syntax: SyntaxNode) -> Option<Self> {1891	fn cast(syntax: SyntaxNode) -> Option<Self> {
1329		if Self::can_cast(syntax.kind()) {1892		if Self::can_cast(syntax.kind()) {
1330			Some(Self { syntax })1893			Some(Self { syntax })
1331		} else {1894		} else {
1332			None1895			None
1333		}1896		}
1334	}1897	}
1335	fn syntax(&self) -> &SyntaxNode { &self.syntax }1898	fn syntax(&self) -> &SyntaxNode {
1899		&self.syntax
1900	}
1336}1901}
1337impl AstNode for DestructFull {1902impl AstNode for DestructSkip {
1338	fn can_cast(kind: SyntaxKind) -> bool { kind == DESTRUCT_FULL }1903	fn can_cast(kind: SyntaxKind) -> bool {
1904		kind == DESTRUCT_SKIP
1905	}
1339	fn cast(syntax: SyntaxNode) -> Option<Self> {1906	fn cast(syntax: SyntaxNode) -> Option<Self> {
1340		if Self::can_cast(syntax.kind()) {1907		if Self::can_cast(syntax.kind()) {
1341			Some(Self { syntax })1908			Some(Self { syntax })
1342		} else {1909		} else {
1343			None1910			None
1344		}1911		}
1345	}1912	}
1346	fn syntax(&self) -> &SyntaxNode { &self.syntax }1913	fn syntax(&self) -> &SyntaxNode {
1914		&self.syntax
1915	}
1347}1916}
1348impl AstNode for DestructSkip {1917impl AstNode for DestructArray {
1349	fn can_cast(kind: SyntaxKind) -> bool { kind == DESTRUCT_SKIP }1918	fn can_cast(kind: SyntaxKind) -> bool {
1919		kind == DESTRUCT_ARRAY
1920	}
1350	fn cast(syntax: SyntaxNode) -> Option<Self> {1921	fn cast(syntax: SyntaxNode) -> Option<Self> {
1351		if Self::can_cast(syntax.kind()) {1922		if Self::can_cast(syntax.kind()) {
1352			Some(Self { syntax })1923			Some(Self { syntax })
1353		} else {1924		} else {
1354			None1925			None
1355		}1926		}
1356	}1927	}
1357	fn syntax(&self) -> &SyntaxNode { &self.syntax }1928	fn syntax(&self) -> &SyntaxNode {
1929		&self.syntax
1930	}
1358}1931}
1359impl AstNode for DestructArray {1932impl AstNode for DestructObject {
1360	fn can_cast(kind: SyntaxKind) -> bool { kind == DESTRUCT_ARRAY }1933	fn can_cast(kind: SyntaxKind) -> bool {
1934		kind == DESTRUCT_OBJECT
1935	}
1361	fn cast(syntax: SyntaxNode) -> Option<Self> {1936	fn cast(syntax: SyntaxNode) -> Option<Self> {
1362		if Self::can_cast(syntax.kind()) {1937		if Self::can_cast(syntax.kind()) {
1363			Some(Self { syntax })1938			Some(Self { syntax })
1364		} else {1939		} else {
1365			None1940			None
1366		}1941		}
1367	}1942	}
1368	fn syntax(&self) -> &SyntaxNode { &self.syntax }1943	fn syntax(&self) -> &SyntaxNode {
1944		&self.syntax
1945	}
1369}1946}
1370impl AstNode for DestructRest {1947impl AstNode for DestructObjectField {
1371	fn can_cast(kind: SyntaxKind) -> bool { kind == DESTRUCT_REST }1948	fn can_cast(kind: SyntaxKind) -> bool {
1949		kind == DESTRUCT_OBJECT_FIELD
1950	}
1372	fn cast(syntax: SyntaxNode) -> Option<Self> {1951	fn cast(syntax: SyntaxNode) -> Option<Self> {
1373		if Self::can_cast(syntax.kind()) {1952		if Self::can_cast(syntax.kind()) {
1374			Some(Self { syntax })1953			Some(Self { syntax })
1375		} else {1954		} else {
1376			None1955			None
1377		}1956		}
1378	}1957	}
1379	fn syntax(&self) -> &SyntaxNode { &self.syntax }1958	fn syntax(&self) -> &SyntaxNode {
1959		&self.syntax
1960	}
1380}1961}
1381impl AstNode for DestructObject {1962impl AstNode for DestructRest {
1382	fn can_cast(kind: SyntaxKind) -> bool { kind == DESTRUCT_OBJECT }1963	fn can_cast(kind: SyntaxKind) -> bool {
1964		kind == DESTRUCT_REST
1965	}
1383	fn cast(syntax: SyntaxNode) -> Option<Self> {1966	fn cast(syntax: SyntaxNode) -> Option<Self> {
1384		if Self::can_cast(syntax.kind()) {1967		if Self::can_cast(syntax.kind()) {
1385			Some(Self { syntax })1968			Some(Self { syntax })
1386		} else {1969		} else {
1387			None1970			None
1388		}1971		}
1389	}1972	}
1390	fn syntax(&self) -> &SyntaxNode { &self.syntax }1973	fn syntax(&self) -> &SyntaxNode {
1974		&self.syntax
1975	}
1391}1976}
1392impl AstNode for DestructObjectField {1977impl AstNode for DestructArrayElement {
1393	fn can_cast(kind: SyntaxKind) -> bool { kind == DESTRUCT_OBJECT_FIELD }1978	fn can_cast(kind: SyntaxKind) -> bool {
1979		kind == DESTRUCT_ARRAY_ELEMENT
1980	}
1394	fn cast(syntax: SyntaxNode) -> Option<Self> {1981	fn cast(syntax: SyntaxNode) -> Option<Self> {
1395		if Self::can_cast(syntax.kind()) {1982		if Self::can_cast(syntax.kind()) {
1396			Some(Self { syntax })1983			Some(Self { syntax })
1397		} else {1984		} else {
1398			None1985			None
1399		}1986		}
1400	}1987	}
1401	fn syntax(&self) -> &SyntaxNode { &self.syntax }1988	fn syntax(&self) -> &SyntaxNode {
1989		&self.syntax
1990	}
1402}1991}
1403impl From<ExprBinary> for Expr {1992impl From<ExprBinary> for Expr {
1404	fn from(node: ExprBinary) -> Expr { Expr::ExprBinary(node) }1993	fn from(node: ExprBinary) -> Expr {
1994		Expr::ExprBinary(node)
1995	}
1405}1996}
1406impl From<ExprUnary> for Expr {1997impl From<ExprUnary> for Expr {
1407	fn from(node: ExprUnary) -> Expr { Expr::ExprUnary(node) }1998	fn from(node: ExprUnary) -> Expr {
1999		Expr::ExprUnary(node)
2000	}
1408}2001}
1409impl From<ExprSlice> for Expr {2002impl From<ExprSlice> for Expr {
1410	fn from(node: ExprSlice) -> Expr { Expr::ExprSlice(node) }2003	fn from(node: ExprSlice) -> Expr {
2004		Expr::ExprSlice(node)
2005	}
1411}2006}
1412impl From<ExprIndex> for Expr {2007impl From<ExprIndex> for Expr {
1413	fn from(node: ExprIndex) -> Expr { Expr::ExprIndex(node) }2008	fn from(node: ExprIndex) -> Expr {
2009		Expr::ExprIndex(node)
2010	}
1414}2011}
1415impl From<ExprIndexExpr> for Expr {2012impl From<ExprIndexExpr> for Expr {
1416	fn from(node: ExprIndexExpr) -> Expr { Expr::ExprIndexExpr(node) }2013	fn from(node: ExprIndexExpr) -> Expr {
2014		Expr::ExprIndexExpr(node)
2015	}
1417}2016}
1418impl From<ExprApply> for Expr {2017impl From<ExprApply> for Expr {
1419	fn from(node: ExprApply) -> Expr { Expr::ExprApply(node) }2018	fn from(node: ExprApply) -> Expr {
2019		Expr::ExprApply(node)
2020	}
1420}2021}
1421impl From<ExprObjExtend> for Expr {2022impl From<ExprObjExtend> for Expr {
1422	fn from(node: ExprObjExtend) -> Expr { Expr::ExprObjExtend(node) }2023	fn from(node: ExprObjExtend) -> Expr {
2024		Expr::ExprObjExtend(node)
2025	}
1423}2026}
1424impl From<ExprParened> for Expr {2027impl From<ExprParened> for Expr {
1425	fn from(node: ExprParened) -> Expr { Expr::ExprParened(node) }2028	fn from(node: ExprParened) -> Expr {
2029		Expr::ExprParened(node)
2030	}
1426}2031}
1427impl From<ExprIntrinsicThisFile> for Expr {2032impl From<ExprIntrinsicThisFile> for Expr {
1428	fn from(node: ExprIntrinsicThisFile) -> Expr { Expr::ExprIntrinsicThisFile(node) }2033	fn from(node: ExprIntrinsicThisFile) -> Expr {
2034		Expr::ExprIntrinsicThisFile(node)
2035	}
1429}2036}
1430impl From<ExprIntrinsicId> for Expr {2037impl From<ExprIntrinsicId> for Expr {
1431	fn from(node: ExprIntrinsicId) -> Expr { Expr::ExprIntrinsicId(node) }2038	fn from(node: ExprIntrinsicId) -> Expr {
2039		Expr::ExprIntrinsicId(node)
2040	}
1432}2041}
1433impl From<ExprIntrinsic> for Expr {2042impl From<ExprIntrinsic> for Expr {
1434	fn from(node: ExprIntrinsic) -> Expr { Expr::ExprIntrinsic(node) }2043	fn from(node: ExprIntrinsic) -> Expr {
2044		Expr::ExprIntrinsic(node)
2045	}
1435}2046}
1436impl From<ExprString> for Expr {2047impl From<ExprString> for Expr {
1437	fn from(node: ExprString) -> Expr { Expr::ExprString(node) }2048	fn from(node: ExprString) -> Expr {
2049		Expr::ExprString(node)
2050	}
1438}2051}
1439impl From<ExprNumber> for Expr {2052impl From<ExprNumber> for Expr {
1440	fn from(node: ExprNumber) -> Expr { Expr::ExprNumber(node) }2053	fn from(node: ExprNumber) -> Expr {
2054		Expr::ExprNumber(node)
2055	}
1441}2056}
2057impl From<ExprLiteral> for Expr {
2058	fn from(node: ExprLiteral) -> Expr {
2059		Expr::ExprLiteral(node)
2060	}
2061}
1442impl From<ExprArray> for Expr {2062impl From<ExprArray> for Expr {
1443	fn from(node: ExprArray) -> Expr { Expr::ExprArray(node) }2063	fn from(node: ExprArray) -> Expr {
2064		Expr::ExprArray(node)
2065	}
1444}2066}
1445impl From<ExprObject> for Expr {2067impl From<ExprObject> for Expr {
1446	fn from(node: ExprObject) -> Expr { Expr::ExprObject(node) }2068	fn from(node: ExprObject) -> Expr {
2069		Expr::ExprObject(node)
2070	}
1447}2071}
1448impl From<ExprArrayComp> for Expr {2072impl From<ExprArrayComp> for Expr {
1449	fn from(node: ExprArrayComp) -> Expr { Expr::ExprArrayComp(node) }2073	fn from(node: ExprArrayComp) -> Expr {
2074		Expr::ExprArrayComp(node)
2075	}
1450}2076}
1451impl From<ExprImport> for Expr {2077impl From<ExprImport> for Expr {
1452	fn from(node: ExprImport) -> Expr { Expr::ExprImport(node) }2078	fn from(node: ExprImport) -> Expr {
2079		Expr::ExprImport(node)
2080	}
1453}2081}
1454impl From<ExprVar> for Expr {2082impl From<ExprVar> for Expr {
1455	fn from(node: ExprVar) -> Expr { Expr::ExprVar(node) }2083	fn from(node: ExprVar) -> Expr {
2084		Expr::ExprVar(node)
2085	}
1456}2086}
1457impl From<ExprLocal> for Expr {2087impl From<ExprLocal> for Expr {
1458	fn from(node: ExprLocal) -> Expr { Expr::ExprLocal(node) }2088	fn from(node: ExprLocal) -> Expr {
2089		Expr::ExprLocal(node)
2090	}
1459}2091}
1460impl From<ExprIfThenElse> for Expr {2092impl From<ExprIfThenElse> for Expr {
1461	fn from(node: ExprIfThenElse) -> Expr { Expr::ExprIfThenElse(node) }2093	fn from(node: ExprIfThenElse) -> Expr {
2094		Expr::ExprIfThenElse(node)
2095	}
1462}2096}
1463impl From<ExprFunction> for Expr {2097impl From<ExprFunction> for Expr {
1464	fn from(node: ExprFunction) -> Expr { Expr::ExprFunction(node) }2098	fn from(node: ExprFunction) -> Expr {
2099		Expr::ExprFunction(node)
2100	}
1465}2101}
1466impl From<ExprAssert> for Expr {2102impl From<ExprAssert> for Expr {
1467	fn from(node: ExprAssert) -> Expr { Expr::ExprAssert(node) }2103	fn from(node: ExprAssert) -> Expr {
2104		Expr::ExprAssert(node)
2105	}
1468}2106}
1469impl From<ExprError> for Expr {2107impl From<ExprError> for Expr {
1470	fn from(node: ExprError) -> Expr { Expr::ExprError(node) }2108	fn from(node: ExprError) -> Expr {
2109		Expr::ExprError(node)
2110	}
1471}2111}
1472impl AstNode for Expr {2112impl AstNode for Expr {
1473	fn can_cast(kind: SyntaxKind) -> bool {2113	fn can_cast(kind: SyntaxKind) -> bool {
1485			| EXPR_INTRINSIC2125			| EXPR_INTRINSIC
1486			| EXPR_STRING2126			| EXPR_STRING
1487			| EXPR_NUMBER2127			| EXPR_NUMBER
2128			| EXPR_LITERAL
1488			| EXPR_ARRAY2129			| EXPR_ARRAY
1489			| EXPR_OBJECT2130			| EXPR_OBJECT
1490			| EXPR_ARRAY_COMP2131			| EXPR_ARRAY_COMP
1515			EXPR_INTRINSIC => Expr::ExprIntrinsic(ExprIntrinsic { syntax }),2156			EXPR_INTRINSIC => Expr::ExprIntrinsic(ExprIntrinsic { syntax }),
1516			EXPR_STRING => Expr::ExprString(ExprString { syntax }),2157			EXPR_STRING => Expr::ExprString(ExprString { syntax }),
1517			EXPR_NUMBER => Expr::ExprNumber(ExprNumber { syntax }),2158			EXPR_NUMBER => Expr::ExprNumber(ExprNumber { syntax }),
2159			EXPR_LITERAL => Expr::ExprLiteral(ExprLiteral { syntax }),
1518			EXPR_ARRAY => Expr::ExprArray(ExprArray { syntax }),2160			EXPR_ARRAY => Expr::ExprArray(ExprArray { syntax }),
1519			EXPR_OBJECT => Expr::ExprObject(ExprObject { syntax }),2161			EXPR_OBJECT => Expr::ExprObject(ExprObject { syntax }),
1520			EXPR_ARRAY_COMP => Expr::ExprArrayComp(ExprArrayComp { syntax }),2162			EXPR_ARRAY_COMP => Expr::ExprArrayComp(ExprArrayComp { syntax }),
1544			Expr::ExprIntrinsic(it) => &it.syntax,2186			Expr::ExprIntrinsic(it) => &it.syntax,
1545			Expr::ExprString(it) => &it.syntax,2187			Expr::ExprString(it) => &it.syntax,
1546			Expr::ExprNumber(it) => &it.syntax,2188			Expr::ExprNumber(it) => &it.syntax,
2189			Expr::ExprLiteral(it) => &it.syntax,
1547			Expr::ExprArray(it) => &it.syntax,2190			Expr::ExprArray(it) => &it.syntax,
1548			Expr::ExprObject(it) => &it.syntax,2191			Expr::ExprObject(it) => &it.syntax,
1549			Expr::ExprArrayComp(it) => &it.syntax,2192			Expr::ExprArrayComp(it) => &it.syntax,
1558	}2201	}
1559}2202}
1560impl From<ObjBodyComp> for ObjBody {2203impl From<ObjBodyComp> for ObjBody {
1561	fn from(node: ObjBodyComp) -> ObjBody { ObjBody::ObjBodyComp(node) }2204	fn from(node: ObjBodyComp) -> ObjBody {
2205		ObjBody::ObjBodyComp(node)
2206	}
1562}2207}
1563impl From<ObjBodyMemberList> for ObjBody {2208impl From<ObjBodyMemberList> for ObjBody {
1564	fn from(node: ObjBodyMemberList) -> ObjBody { ObjBody::ObjBodyMemberList(node) }2209	fn from(node: ObjBodyMemberList) -> ObjBody {
2210		ObjBody::ObjBodyMemberList(node)
2211	}
1565}2212}
1566impl AstNode for ObjBody {2213impl AstNode for ObjBody {
1567	fn can_cast(kind: SyntaxKind) -> bool {2214	fn can_cast(kind: SyntaxKind) -> bool {
1586	}2233	}
1587}2234}
1588impl From<ForSpec> for CompSpec {2235impl From<ForSpec> for CompSpec {
1589	fn from(node: ForSpec) -> CompSpec { CompSpec::ForSpec(node) }2236	fn from(node: ForSpec) -> CompSpec {
2237		CompSpec::ForSpec(node)
2238	}
1590}2239}
1591impl From<IfSpec> for CompSpec {2240impl From<IfSpec> for CompSpec {
1592	fn from(node: IfSpec) -> CompSpec { CompSpec::IfSpec(node) }2241	fn from(node: IfSpec) -> CompSpec {
2242		CompSpec::IfSpec(node)
2243	}
1593}2244}
1594impl AstNode for CompSpec {2245impl AstNode for CompSpec {
1595	fn can_cast(kind: SyntaxKind) -> bool {2246	fn can_cast(kind: SyntaxKind) -> bool {
1614	}2265	}
1615}2266}
1616impl From<BindDestruct> for Bind {2267impl From<BindDestruct> for Bind {
1617	fn from(node: BindDestruct) -> Bind { Bind::BindDestruct(node) }2268	fn from(node: BindDestruct) -> Bind {
2269		Bind::BindDestruct(node)
2270	}
1618}2271}
1619impl From<BindFunction> for Bind {2272impl From<BindFunction> for Bind {
1620	fn from(node: BindFunction) -> Bind { Bind::BindFunction(node) }2273	fn from(node: BindFunction) -> Bind {
2274		Bind::BindFunction(node)
2275	}
1621}2276}
1622impl AstNode for Bind {2277impl AstNode for Bind {
1623	fn can_cast(kind: SyntaxKind) -> bool {2278	fn can_cast(kind: SyntaxKind) -> bool {
1642	}2297	}
1643}2298}
1644impl From<MemberBindStmt> for Member {2299impl From<MemberBindStmt> for Member {
1645	fn from(node: MemberBindStmt) -> Member { Member::MemberBindStmt(node) }2300	fn from(node: MemberBindStmt) -> Member {
2301		Member::MemberBindStmt(node)
2302	}
1646}2303}
1647impl From<MemberAssertStmt> for Member {2304impl From<MemberAssertStmt> for Member {
1648	fn from(node: MemberAssertStmt) -> Member { Member::MemberAssertStmt(node) }2305	fn from(node: MemberAssertStmt) -> Member {
2306		Member::MemberAssertStmt(node)
2307	}
1649}2308}
1650impl From<MemberField> for Member {2309impl From<MemberField> for Member {
1651	fn from(node: MemberField) -> Member { Member::MemberField(node) }2310	fn from(node: MemberField) -> Member {
2311		Member::MemberField(node)
2312	}
1652}2313}
1653impl AstNode for Member {2314impl AstNode for Member {
1654	fn can_cast(kind: SyntaxKind) -> bool {2315	fn can_cast(kind: SyntaxKind) -> bool {
1675	}2336	}
1676}2337}
1677impl From<FieldNormal> for Field {2338impl From<FieldNormal> for Field {
1678	fn from(node: FieldNormal) -> Field { Field::FieldNormal(node) }2339	fn from(node: FieldNormal) -> Field {
2340		Field::FieldNormal(node)
2341	}
1679}2342}
1680impl From<FieldMethod> for Field {2343impl From<FieldMethod> for Field {
1681	fn from(node: FieldMethod) -> Field { Field::FieldMethod(node) }2344	fn from(node: FieldMethod) -> Field {
2345		Field::FieldMethod(node)
2346	}
1682}2347}
1683impl AstNode for Field {2348impl AstNode for Field {
1684	fn can_cast(kind: SyntaxKind) -> bool {2349	fn can_cast(kind: SyntaxKind) -> bool {
1703	}2368	}
1704}2369}
1705impl From<FieldNameFixed> for FieldName {2370impl From<FieldNameFixed> for FieldName {
1706	fn from(node: FieldNameFixed) -> FieldName { FieldName::FieldNameFixed(node) }2371	fn from(node: FieldNameFixed) -> FieldName {
2372		FieldName::FieldNameFixed(node)
2373	}
1707}2374}
1708impl From<FieldNameDynamic> for FieldName {2375impl From<FieldNameDynamic> for FieldName {
1709	fn from(node: FieldNameDynamic) -> FieldName { FieldName::FieldNameDynamic(node) }2376	fn from(node: FieldNameDynamic) -> FieldName {
2377		FieldName::FieldNameDynamic(node)
2378	}
1710}2379}
1711impl AstNode for FieldName {2380impl AstNode for FieldName {
1712	fn can_cast(kind: SyntaxKind) -> bool {2381	fn can_cast(kind: SyntaxKind) -> bool {
1730		}2399		}
1731	}2400	}
1732}2401}
2402impl From<DestructFull> for Destruct {
2403	fn from(node: DestructFull) -> Destruct {
2404		Destruct::DestructFull(node)
2405	}
2406}
2407impl From<DestructSkip> for Destruct {
2408	fn from(node: DestructSkip) -> Destruct {
2409		Destruct::DestructSkip(node)
2410	}
2411}
2412impl From<DestructArray> for Destruct {
2413	fn from(node: DestructArray) -> Destruct {
2414		Destruct::DestructArray(node)
2415	}
2416}
2417impl From<DestructObject> for Destruct {
2418	fn from(node: DestructObject) -> Destruct {
2419		Destruct::DestructObject(node)
2420	}
2421}
2422impl AstNode for Destruct {
2423	fn can_cast(kind: SyntaxKind) -> bool {
2424		match kind {
2425			DESTRUCT_FULL | DESTRUCT_SKIP | DESTRUCT_ARRAY | DESTRUCT_OBJECT => true,
2426			_ => false,
2427		}
2428	}
2429	fn cast(syntax: SyntaxNode) -> Option<Self> {
2430		let res = match syntax.kind() {
2431			DESTRUCT_FULL => Destruct::DestructFull(DestructFull { syntax }),
2432			DESTRUCT_SKIP => Destruct::DestructSkip(DestructSkip { syntax }),
2433			DESTRUCT_ARRAY => Destruct::DestructArray(DestructArray { syntax }),
2434			DESTRUCT_OBJECT => Destruct::DestructObject(DestructObject { syntax }),
2435			_ => return None,
2436		};
2437		Some(res)
2438	}
2439	fn syntax(&self) -> &SyntaxNode {
2440		match self {
2441			Destruct::DestructFull(it) => &it.syntax,
2442			Destruct::DestructSkip(it) => &it.syntax,
2443			Destruct::DestructArray(it) => &it.syntax,
2444			Destruct::DestructObject(it) => &it.syntax,
2445		}
2446	}
2447}
2448impl From<DestructArrayElement> for DestructArrayPart {
2449	fn from(node: DestructArrayElement) -> DestructArrayPart {
2450		DestructArrayPart::DestructArrayElement(node)
2451	}
2452}
2453impl From<DestructRest> for DestructArrayPart {
2454	fn from(node: DestructRest) -> DestructArrayPart {
2455		DestructArrayPart::DestructRest(node)
2456	}
2457}
2458impl AstNode for DestructArrayPart {
2459	fn can_cast(kind: SyntaxKind) -> bool {
2460		match kind {
2461			DESTRUCT_ARRAY_ELEMENT | DESTRUCT_REST => true,
2462			_ => false,
2463		}
2464	}
2465	fn cast(syntax: SyntaxNode) -> Option<Self> {
2466		let res = match syntax.kind() {
2467			DESTRUCT_ARRAY_ELEMENT => {
2468				DestructArrayPart::DestructArrayElement(DestructArrayElement { syntax })
2469			}
2470			DESTRUCT_REST => DestructArrayPart::DestructRest(DestructRest { syntax }),
2471			_ => return None,
2472		};
2473		Some(res)
2474	}
2475	fn syntax(&self) -> &SyntaxNode {
2476		match self {
2477			DestructArrayPart::DestructArrayElement(it) => &it.syntax,
2478			DestructArrayPart::DestructRest(it) => &it.syntax,
2479		}
2480	}
2481}
2482impl AstToken for BinaryOperator {
2483	fn can_cast(kind: SyntaxKind) -> bool {
2484		match kind {
2485			OR | AND | BIT_OR | BIT_XOR | BIT_AND | EQ | NE | LT | GT | LE | GE | IN_KW | LHS
2486			| RHS | PLUS | MINUS | MUL | DIV | MODULO | ERROR_NO_OPERATOR => true,
2487			_ => false,
2488		}
2489	}
2490	fn cast(syntax: SyntaxToken) -> Option<Self> {
2491		let res = match syntax.kind() {
2492			OR => BinaryOperator {
2493				syntax,
2494				kind: BinaryOperatorKind::Or,
2495			},
2496			AND => BinaryOperator {
2497				syntax,
2498				kind: BinaryOperatorKind::And,
2499			},
2500			BIT_OR => BinaryOperator {
2501				syntax,
2502				kind: BinaryOperatorKind::BitOr,
2503			},
2504			BIT_XOR => BinaryOperator {
2505				syntax,
2506				kind: BinaryOperatorKind::BitXor,
2507			},
2508			BIT_AND => BinaryOperator {
2509				syntax,
2510				kind: BinaryOperatorKind::BitAnd,
2511			},
2512			EQ => BinaryOperator {
2513				syntax,
2514				kind: BinaryOperatorKind::Eq,
2515			},
2516			NE => BinaryOperator {
2517				syntax,
2518				kind: BinaryOperatorKind::Ne,
2519			},
2520			LT => BinaryOperator {
2521				syntax,
2522				kind: BinaryOperatorKind::Lt,
2523			},
2524			GT => BinaryOperator {
2525				syntax,
2526				kind: BinaryOperatorKind::Gt,
2527			},
2528			LE => BinaryOperator {
2529				syntax,
2530				kind: BinaryOperatorKind::Le,
2531			},
2532			GE => BinaryOperator {
2533				syntax,
2534				kind: BinaryOperatorKind::Ge,
2535			},
2536			IN_KW => BinaryOperator {
2537				syntax,
2538				kind: BinaryOperatorKind::InKw,
2539			},
2540			LHS => BinaryOperator {
2541				syntax,
2542				kind: BinaryOperatorKind::Lhs,
2543			},
2544			RHS => BinaryOperator {
2545				syntax,
2546				kind: BinaryOperatorKind::Rhs,
2547			},
2548			PLUS => BinaryOperator {
2549				syntax,
2550				kind: BinaryOperatorKind::Plus,
2551			},
2552			MINUS => BinaryOperator {
2553				syntax,
2554				kind: BinaryOperatorKind::Minus,
2555			},
2556			MUL => BinaryOperator {
2557				syntax,
2558				kind: BinaryOperatorKind::Mul,
2559			},
2560			DIV => BinaryOperator {
2561				syntax,
2562				kind: BinaryOperatorKind::Div,
2563			},
2564			MODULO => BinaryOperator {
2565				syntax,
2566				kind: BinaryOperatorKind::Modulo,
2567			},
2568			ERROR_NO_OPERATOR => BinaryOperator {
2569				syntax,
2570				kind: BinaryOperatorKind::ErrorNoOperator,
2571			},
2572			_ => return None,
2573		};
2574		Some(res)
2575	}
2576	fn syntax(&self) -> &SyntaxToken {
2577		&self.syntax
2578	}
2579}
2580impl BinaryOperator {
2581	pub fn kind(&self) -> BinaryOperatorKind {
2582		self.kind
2583	}
2584}
2585impl std::fmt::Display for BinaryOperator {
2586	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2587		std::fmt::Display::fmt(self.syntax(), f)
2588	}
2589}
2590impl AstToken for UnaryOperator {
2591	fn can_cast(kind: SyntaxKind) -> bool {
2592		match kind {
2593			MINUS | NOT | BIT_NOT => true,
2594			_ => false,
2595		}
2596	}
2597	fn cast(syntax: SyntaxToken) -> Option<Self> {
2598		let res = match syntax.kind() {
2599			MINUS => UnaryOperator {
2600				syntax,
2601				kind: UnaryOperatorKind::Minus,
2602			},
2603			NOT => UnaryOperator {
2604				syntax,
2605				kind: UnaryOperatorKind::Not,
2606			},
2607			BIT_NOT => UnaryOperator {
2608				syntax,
2609				kind: UnaryOperatorKind::BitNot,
2610			},
2611			_ => return None,
2612		};
2613		Some(res)
2614	}
2615	fn syntax(&self) -> &SyntaxToken {
2616		&self.syntax
2617	}
2618}
2619impl UnaryOperator {
2620	pub fn kind(&self) -> UnaryOperatorKind {
2621		self.kind
2622	}
2623}
2624impl std::fmt::Display for UnaryOperator {
2625	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2626		std::fmt::Display::fmt(self.syntax(), f)
2627	}
2628}
2629impl AstToken for Literal {
2630	fn can_cast(kind: SyntaxKind) -> bool {
2631		match kind {
2632			NULL_KW | TRUE_KW | FALSE_KW | SELF_KW | DOLLAR | SUPER_KW => true,
2633			_ => false,
2634		}
2635	}
2636	fn cast(syntax: SyntaxToken) -> Option<Self> {
2637		let res = match syntax.kind() {
2638			NULL_KW => Literal {
2639				syntax,
2640				kind: LiteralKind::NullKw,
2641			},
2642			TRUE_KW => Literal {
2643				syntax,
2644				kind: LiteralKind::TrueKw,
2645			},
2646			FALSE_KW => Literal {
2647				syntax,
2648				kind: LiteralKind::FalseKw,
2649			},
2650			SELF_KW => Literal {
2651				syntax,
2652				kind: LiteralKind::SelfKw,
2653			},
2654			DOLLAR => Literal {
2655				syntax,
2656				kind: LiteralKind::Dollar,
2657			},
2658			SUPER_KW => Literal {
2659				syntax,
2660				kind: LiteralKind::SuperKw,
2661			},
2662			_ => return None,
2663		};
2664		Some(res)
2665	}
2666	fn syntax(&self) -> &SyntaxToken {
2667		&self.syntax
2668	}
2669}
2670impl Literal {
2671	pub fn kind(&self) -> LiteralKind {
2672		self.kind
2673	}
2674}
2675impl std::fmt::Display for Literal {
2676	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2677		std::fmt::Display::fmt(self.syntax(), f)
2678	}
2679}
2680impl AstToken for String {
2681	fn can_cast(kind: SyntaxKind) -> bool {
2682		match kind {
2683			STRING_DOUBLE
2684			| STRING_SINGLE
2685			| STRING_DOUBLE_VERBATIM
2686			| STRING_SINGLE_VERBATIM
2687			| STRING_BLOCK => true,
2688			_ => false,
2689		}
2690	}
2691	fn cast(syntax: SyntaxToken) -> Option<Self> {
2692		let res = match syntax.kind() {
2693			STRING_DOUBLE => String {
2694				syntax,
2695				kind: StringKind::StringDouble,
2696			},
2697			STRING_SINGLE => String {
2698				syntax,
2699				kind: StringKind::StringSingle,
2700			},
2701			STRING_DOUBLE_VERBATIM => String {
2702				syntax,
2703				kind: StringKind::StringDoubleVerbatim,
2704			},
2705			STRING_SINGLE_VERBATIM => String {
2706				syntax,
2707				kind: StringKind::StringSingleVerbatim,
2708			},
2709			STRING_BLOCK => String {
2710				syntax,
2711				kind: StringKind::StringBlock,
2712			},
2713			_ => return None,
2714		};
2715		Some(res)
2716	}
2717	fn syntax(&self) -> &SyntaxToken {
2718		&self.syntax
2719	}
2720}
2721impl String {
2722	pub fn kind(&self) -> StringKind {
2723		self.kind
2724	}
2725}
2726impl std::fmt::Display for String {
2727	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2728		std::fmt::Display::fmt(self.syntax(), f)
2729	}
2730}
2731impl AstToken for Number {
2732	fn can_cast(kind: SyntaxKind) -> bool {
2733		match kind {
2734			FLOAT | META_FORCE_ENUM => true,
2735			_ => false,
2736		}
2737	}
2738	fn cast(syntax: SyntaxToken) -> Option<Self> {
2739		let res = match syntax.kind() {
2740			FLOAT => Number {
2741				syntax,
2742				kind: NumberKind::Float,
2743			},
2744			META_FORCE_ENUM => Number {
2745				syntax,
2746				kind: NumberKind::MetaForceEnum,
2747			},
2748			_ => return None,
2749		};
2750		Some(res)
2751	}
2752	fn syntax(&self) -> &SyntaxToken {
2753		&self.syntax
2754	}
2755}
2756impl Number {
2757	pub fn kind(&self) -> NumberKind {
2758		self.kind
2759	}
2760}
2761impl std::fmt::Display for Number {
2762	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2763		std::fmt::Display::fmt(self.syntax(), f)
2764	}
2765}
2766impl AstToken for ImportKind {
2767	fn can_cast(kind: SyntaxKind) -> bool {
2768		match kind {
2769			IMPORTSTR_KW | IMPORTBIN_KW | IMPORT_KW => true,
2770			_ => false,
2771		}
2772	}
2773	fn cast(syntax: SyntaxToken) -> Option<Self> {
2774		let res = match syntax.kind() {
2775			IMPORTSTR_KW => ImportKind {
2776				syntax,
2777				kind: ImportKindKind::ImportstrKw,
2778			},
2779			IMPORTBIN_KW => ImportKind {
2780				syntax,
2781				kind: ImportKindKind::ImportbinKw,
2782			},
2783			IMPORT_KW => ImportKind {
2784				syntax,
2785				kind: ImportKindKind::ImportKw,
2786			},
2787			_ => return None,
2788		};
2789		Some(res)
2790	}
2791	fn syntax(&self) -> &SyntaxToken {
2792		&self.syntax
2793	}
2794}
2795impl ImportKind {
2796	pub fn kind(&self) -> ImportKindKind {
2797		self.kind
2798	}
2799}
2800impl std::fmt::Display for ImportKind {
2801	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2802		std::fmt::Display::fmt(self.syntax(), f)
2803	}
2804}
2805impl AstToken for Visibility {
2806	fn can_cast(kind: SyntaxKind) -> bool {
2807		match kind {
2808			COLONCOLONCOLON | COLONCOLON | COLON => true,
2809			_ => false,
2810		}
2811	}
2812	fn cast(syntax: SyntaxToken) -> Option<Self> {
2813		let res = match syntax.kind() {
2814			COLONCOLONCOLON => Visibility {
2815				syntax,
2816				kind: VisibilityKind::Coloncoloncolon,
2817			},
2818			COLONCOLON => Visibility {
2819				syntax,
2820				kind: VisibilityKind::Coloncolon,
2821			},
2822			COLON => Visibility {
2823				syntax,
2824				kind: VisibilityKind::Colon,
2825			},
2826			_ => return None,
2827		};
2828		Some(res)
2829	}
2830	fn syntax(&self) -> &SyntaxToken {
2831		&self.syntax
2832	}
2833}
2834impl Visibility {
2835	pub fn kind(&self) -> VisibilityKind {
2836		self.kind
2837	}
2838}
2839impl std::fmt::Display for Visibility {
2840	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2841		std::fmt::Display::fmt(self.syntax(), f)
2842	}
2843}
1733impl std::fmt::Display for Expr {2844impl std::fmt::Display for Expr {
1734	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2845	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1735		std::fmt::Display::fmt(self.syntax(), f)2846		std::fmt::Display::fmt(self.syntax(), f)
1765		std::fmt::Display::fmt(self.syntax(), f)2876		std::fmt::Display::fmt(self.syntax(), f)
1766	}2877	}
1767}2878}
1768impl std::fmt::Display for SourceFile {2879impl std::fmt::Display for Destruct {
1769	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2880	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1770		std::fmt::Display::fmt(self.syntax(), f)2881		std::fmt::Display::fmt(self.syntax(), f)
1771	}2882	}
1772}2883}
1773impl std::fmt::Display for ExprBinary {2884impl std::fmt::Display for DestructArrayPart {
1774	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2885	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1775		std::fmt::Display::fmt(self.syntax(), f)2886		std::fmt::Display::fmt(self.syntax(), f)
1776	}2887	}
1777}2888}
1778impl std::fmt::Display for BinaryOperator {2889impl std::fmt::Display for SourceFile {
1779	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2890	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1780		std::fmt::Display::fmt(self.syntax(), f)2891		std::fmt::Display::fmt(self.syntax(), f)
1781	}2892	}
1782}2893}
1783impl std::fmt::Display for ExprUnary {2894impl std::fmt::Display for ExprBinary {
1784	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2895	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1785		std::fmt::Display::fmt(self.syntax(), f)2896		std::fmt::Display::fmt(self.syntax(), f)
1786	}2897	}
1787}2898}
1788impl std::fmt::Display for UnaryOperator {2899impl std::fmt::Display for LhsExpr {
1789	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2900	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1790		std::fmt::Display::fmt(self.syntax(), f)2901		std::fmt::Display::fmt(self.syntax(), f)
1791	}2902	}
1792}2903}
2904impl std::fmt::Display for ExprUnary {
2905	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2906		std::fmt::Display::fmt(self.syntax(), f)
2907	}
2908}
1793impl std::fmt::Display for ExprSlice {2909impl std::fmt::Display for ExprSlice {
1794	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2910	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1795		std::fmt::Display::fmt(self.syntax(), f)2911		std::fmt::Display::fmt(self.syntax(), f)
1840		std::fmt::Display::fmt(self.syntax(), f)2956		std::fmt::Display::fmt(self.syntax(), f)
1841	}2957	}
1842}2958}
1843impl std::fmt::Display for Literal {
1844	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1845		std::fmt::Display::fmt(self.syntax(), f)
1846	}
1847}
1848impl std::fmt::Display for ExprIntrinsicThisFile {2959impl std::fmt::Display for ExprIntrinsicThisFile {
1849	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2960	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1850		std::fmt::Display::fmt(self.syntax(), f)2961		std::fmt::Display::fmt(self.syntax(), f)
1865		std::fmt::Display::fmt(self.syntax(), f)2976		std::fmt::Display::fmt(self.syntax(), f)
1866	}2977	}
1867}2978}
1868impl std::fmt::Display for String {
1869	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1870		std::fmt::Display::fmt(self.syntax(), f)
1871	}
1872}
1873impl std::fmt::Display for ExprNumber {2979impl std::fmt::Display for ExprNumber {
1874	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2980	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1875		std::fmt::Display::fmt(self.syntax(), f)2981		std::fmt::Display::fmt(self.syntax(), f)
1876	}2982	}
1877}2983}
1878impl std::fmt::Display for Number {2984impl std::fmt::Display for ExprArray {
1879	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2985	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1880		std::fmt::Display::fmt(self.syntax(), f)2986		std::fmt::Display::fmt(self.syntax(), f)
1881	}2987	}
1882}2988}
1883impl std::fmt::Display for ExprArray {2989impl std::fmt::Display for ExprObject {
1884	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2990	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1885		std::fmt::Display::fmt(self.syntax(), f)2991		std::fmt::Display::fmt(self.syntax(), f)
1886	}2992	}
1887}2993}
1888impl std::fmt::Display for ExprObject {2994impl std::fmt::Display for ExprArrayComp {
1889	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2995	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1890		std::fmt::Display::fmt(self.syntax(), f)2996		std::fmt::Display::fmt(self.syntax(), f)
1891	}2997	}
1892}2998}
1893impl std::fmt::Display for ExprArrayComp {2999impl std::fmt::Display for ExprImport {
1894	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3000	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1895		std::fmt::Display::fmt(self.syntax(), f)3001		std::fmt::Display::fmt(self.syntax(), f)
1896	}3002	}
1897}3003}
1898impl std::fmt::Display for ForSpec {3004impl std::fmt::Display for ExprVar {
1899	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3005	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1900		std::fmt::Display::fmt(self.syntax(), f)3006		std::fmt::Display::fmt(self.syntax(), f)
1901	}3007	}
1902}3008}
1903impl std::fmt::Display for ExprImport {3009impl std::fmt::Display for ExprLocal {
1904	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3010	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1905		std::fmt::Display::fmt(self.syntax(), f)3011		std::fmt::Display::fmt(self.syntax(), f)
1906	}3012	}
1907}3013}
1908impl std::fmt::Display for ExprVar {3014impl std::fmt::Display for ExprIfThenElse {
1909	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3015	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1910		std::fmt::Display::fmt(self.syntax(), f)3016		std::fmt::Display::fmt(self.syntax(), f)
1911	}3017	}
1912}3018}
1913impl std::fmt::Display for ExprLocal {3019impl std::fmt::Display for TrueExpr {
1914	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3020	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1915		std::fmt::Display::fmt(self.syntax(), f)3021		std::fmt::Display::fmt(self.syntax(), f)
1916	}3022	}
1917}3023}
1918impl std::fmt::Display for ExprIfThenElse {3024impl std::fmt::Display for FalseExpr {
1919	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3025	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1920		std::fmt::Display::fmt(self.syntax(), f)3026		std::fmt::Display::fmt(self.syntax(), f)
1921	}3027	}
1945		std::fmt::Display::fmt(self.syntax(), f)3051		std::fmt::Display::fmt(self.syntax(), f)
1946	}3052	}
1947}3053}
3054impl std::fmt::Display for SliceDescEnd {
3055	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3056		std::fmt::Display::fmt(self.syntax(), f)
3057	}
3058}
3059impl std::fmt::Display for SliceDescStep {
3060	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3061		std::fmt::Display::fmt(self.syntax(), f)
3062	}
3063}
1948impl std::fmt::Display for Arg {3064impl std::fmt::Display for Arg {
1949	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3065	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1950		std::fmt::Display::fmt(self.syntax(), f)3066		std::fmt::Display::fmt(self.syntax(), f)
1995		std::fmt::Display::fmt(self.syntax(), f)3111		std::fmt::Display::fmt(self.syntax(), f)
1996	}3112	}
1997}3113}
1998impl std::fmt::Display for Visibility {
1999	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2000		std::fmt::Display::fmt(self.syntax(), f)
2001	}
2002}
2003impl std::fmt::Display for FieldMethod {3114impl std::fmt::Display for FieldMethod {
2004	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3115	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2005		std::fmt::Display::fmt(self.syntax(), f)3116		std::fmt::Display::fmt(self.syntax(), f)
2015		std::fmt::Display::fmt(self.syntax(), f)3126		std::fmt::Display::fmt(self.syntax(), f)
2016	}3127	}
2017}3128}
2018impl std::fmt::Display for IfSpec {3129impl std::fmt::Display for ForSpec {
2019	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3130	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2020		std::fmt::Display::fmt(self.syntax(), f)3131		std::fmt::Display::fmt(self.syntax(), f)
2021	}3132	}
2022}3133}
2023impl std::fmt::Display for BindDestruct {3134impl std::fmt::Display for IfSpec {
2024	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3135	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2025		std::fmt::Display::fmt(self.syntax(), f)3136		std::fmt::Display::fmt(self.syntax(), f)
2026	}3137	}
2027}3138}
2028impl std::fmt::Display for Destruct {3139impl std::fmt::Display for BindDestruct {
2029	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3140	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2030		std::fmt::Display::fmt(self.syntax(), f)3141		std::fmt::Display::fmt(self.syntax(), f)
2031	}3142	}
2055		std::fmt::Display::fmt(self.syntax(), f)3166		std::fmt::Display::fmt(self.syntax(), f)
2056	}3167	}
2057}3168}
2058impl std::fmt::Display for DestructRest {3169impl std::fmt::Display for DestructObject {
2059	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3170	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2060		std::fmt::Display::fmt(self.syntax(), f)3171		std::fmt::Display::fmt(self.syntax(), f)
2061	}3172	}
2062}3173}
2063impl std::fmt::Display for DestructObject {3174impl std::fmt::Display for DestructObjectField {
2064	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3175	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2065		std::fmt::Display::fmt(self.syntax(), f)3176		std::fmt::Display::fmt(self.syntax(), f)
2066	}3177	}
2067}3178}
2068impl std::fmt::Display for DestructObjectField {3179impl std::fmt::Display for DestructRest {
3180	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3181		std::fmt::Display::fmt(self.syntax(), f)
3182	}
3183}
3184impl std::fmt::Display for DestructArrayElement {
2069	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3185	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2070		std::fmt::Display::fmt(self.syntax(), f)3186		std::fmt::Display::fmt(self.syntax(), f)
2071	}3187	}