git.delta.rocks / jrsonnet / refs/commits / 0b2a41fa24cc

1//! This is a generated file, please do not edit manually. Changes can be2//! made in codegeneration that lives in `xtask` top-level dir.34#![allow(non_snake_case, clippy::match_like_matches_macro)]5use crate::{6	ast::{support, AstChildren, AstNode, AstToken},7	SyntaxKind::{self, *},8	SyntaxNode, SyntaxToken, T,9};1011#[derive(Debug, Clone, PartialEq, Eq, Hash)]12pub struct SourceFile {13	pub(crate) syntax: SyntaxNode,14}15impl SourceFile {16	pub fn expr(&self) -> Option<Expr> {17		support::children(&self.syntax).next()18	}19}2021#[derive(Debug, Clone, PartialEq, Eq, Hash)]22pub struct Expr {23	pub(crate) syntax: SyntaxNode,24}25impl Expr {26	pub fn stmts(&self) -> AstChildren<Stmt> {27		support::children(&self.syntax)28	}29	pub fn expr_base(&self) -> Option<ExprBase> {30		support::children(&self.syntax).next()31	}32	pub fn suffixs(&self) -> AstChildren<Suffix> {33		support::children(&self.syntax)34	}35}3637#[derive(Debug, Clone, PartialEq, Eq, Hash)]38pub struct SuffixIndex {39	pub(crate) syntax: SyntaxNode,40}41impl SuffixIndex {42	pub fn question_mark_token(&self) -> Option<SyntaxToken> {43		support::token(&self.syntax, T![?])44	}45	pub fn dot_token(&self) -> Option<SyntaxToken> {46		support::token(&self.syntax, T![.])47	}48	pub fn index(&self) -> Option<Name> {49		support::children(&self.syntax).next()50	}51}5253#[derive(Debug, Clone, PartialEq, Eq, Hash)]54pub struct Name {55	pub(crate) syntax: SyntaxNode,56}57impl Name {58	pub fn ident_lit(&self) -> Option<SyntaxToken> {59		support::token(&self.syntax, IDENT)60	}61}6263#[derive(Debug, Clone, PartialEq, Eq, Hash)]64pub struct SuffixIndexExpr {65	pub(crate) syntax: SyntaxNode,66}67impl SuffixIndexExpr {68	pub fn question_mark_token(&self) -> Option<SyntaxToken> {69		support::token(&self.syntax, T![?])70	}71	pub fn dot_token(&self) -> Option<SyntaxToken> {72		support::token(&self.syntax, T![.])73	}74	pub fn l_brack_token(&self) -> Option<SyntaxToken> {75		support::token(&self.syntax, T!['['])76	}77	pub fn index(&self) -> Option<Expr> {78		support::children(&self.syntax).next()79	}80	pub fn r_brack_token(&self) -> Option<SyntaxToken> {81		support::token(&self.syntax, T![']'])82	}83}8485#[derive(Debug, Clone, PartialEq, Eq, Hash)]86pub struct SuffixSlice {87	pub(crate) syntax: SyntaxNode,88}89impl SuffixSlice {90	pub fn slice_desc(&self) -> Option<SliceDesc> {91		support::children(&self.syntax).next()92	}93}9495#[derive(Debug, Clone, PartialEq, Eq, Hash)]96pub struct SliceDesc {97	pub(crate) syntax: SyntaxNode,98}99impl SliceDesc {100	pub fn l_brack_token(&self) -> Option<SyntaxToken> {101		support::token(&self.syntax, T!['['])102	}103	pub fn from(&self) -> Option<Expr> {104		support::children(&self.syntax).next()105	}106	pub fn colon_token(&self) -> Option<SyntaxToken> {107		support::token(&self.syntax, T![:])108	}109	pub fn end(&self) -> Option<SliceDescEnd> {110		support::children(&self.syntax).next()111	}112	pub fn step(&self) -> Option<SliceDescStep> {113		support::children(&self.syntax).next()114	}115	pub fn r_brack_token(&self) -> Option<SyntaxToken> {116		support::token(&self.syntax, T![']'])117	}118}119120#[derive(Debug, Clone, PartialEq, Eq, Hash)]121pub struct SuffixApply {122	pub(crate) syntax: SyntaxNode,123}124impl SuffixApply {125	pub fn args_desc(&self) -> Option<ArgsDesc> {126		support::children(&self.syntax).next()127	}128	pub fn tailstrict_kw_token(&self) -> Option<SyntaxToken> {129		support::token(&self.syntax, T![tailstrict])130	}131}132133#[derive(Debug, Clone, PartialEq, Eq, Hash)]134pub struct ArgsDesc {135	pub(crate) syntax: SyntaxNode,136}137impl ArgsDesc {138	pub fn l_paren_token(&self) -> Option<SyntaxToken> {139		support::token(&self.syntax, T!['('])140	}141	pub fn args(&self) -> AstChildren<Arg> {142		support::children(&self.syntax)143	}144	pub fn r_paren_token(&self) -> Option<SyntaxToken> {145		support::token(&self.syntax, T![')'])146	}147}148149#[derive(Debug, Clone, PartialEq, Eq, Hash)]150pub struct StmtLocal {151	pub(crate) syntax: SyntaxNode,152}153impl StmtLocal {154	pub fn local_kw_token(&self) -> Option<SyntaxToken> {155		support::token(&self.syntax, T![local])156	}157	pub fn binds(&self) -> AstChildren<Bind> {158		support::children(&self.syntax)159	}160	pub fn semi_token(&self) -> Option<SyntaxToken> {161		support::token(&self.syntax, T![;])162	}163}164165#[derive(Debug, Clone, PartialEq, Eq, Hash)]166pub struct StmtAssert {167	pub(crate) syntax: SyntaxNode,168}169impl StmtAssert {170	pub fn assertion(&self) -> Option<Assertion> {171		support::children(&self.syntax).next()172	}173	pub fn semi_token(&self) -> Option<SyntaxToken> {174		support::token(&self.syntax, T![;])175	}176}177178#[derive(Debug, Clone, PartialEq, Eq, Hash)]179pub struct Assertion {180	pub(crate) syntax: SyntaxNode,181}182impl Assertion {183	pub fn assert_kw_token(&self) -> Option<SyntaxToken> {184		support::token(&self.syntax, T![assert])185	}186	pub fn condition(&self) -> Option<Expr> {187		support::children(&self.syntax).next()188	}189	pub fn colon_token(&self) -> Option<SyntaxToken> {190		support::token(&self.syntax, T![:])191	}192	pub fn message(&self) -> Option<Expr> {193		support::children(&self.syntax).nth(1usize)194	}195}196197#[derive(Debug, Clone, PartialEq, Eq, Hash)]198pub struct ExprBinary {199	pub(crate) syntax: SyntaxNode,200}201impl ExprBinary {202	pub fn lhs(&self) -> Option<Expr> {203		support::children(&self.syntax).next()204	}205	pub fn binary_operator(&self) -> Option<BinaryOperator> {206		support::token_child(&self.syntax)207	}208	pub fn rhs(&self) -> Option<Expr> {209		support::children(&self.syntax).nth(1usize)210	}211}212213#[derive(Debug, Clone, PartialEq, Eq, Hash)]214pub struct ExprUnary {215	pub(crate) syntax: SyntaxNode,216}217impl ExprUnary {218	pub fn unary_operator(&self) -> Option<UnaryOperator> {219		support::token_child(&self.syntax)220	}221	pub fn rhs(&self) -> Option<Expr> {222		support::children(&self.syntax).next()223	}224}225226#[derive(Debug, Clone, PartialEq, Eq, Hash)]227pub struct ExprObjExtend {228	pub(crate) syntax: SyntaxNode,229}230impl ExprObjExtend {231	pub fn lhs(&self) -> Option<Expr> {232		support::children(&self.syntax).next()233	}234	pub fn rhs(&self) -> Option<Expr> {235		support::children(&self.syntax).nth(1usize)236	}237}238239#[derive(Debug, Clone, PartialEq, Eq, Hash)]240pub struct ExprParened {241	pub(crate) syntax: SyntaxNode,242}243impl ExprParened {244	pub fn l_paren_token(&self) -> Option<SyntaxToken> {245		support::token(&self.syntax, T!['('])246	}247	pub fn expr(&self) -> Option<Expr> {248		support::children(&self.syntax).next()249	}250	pub fn r_paren_token(&self) -> Option<SyntaxToken> {251		support::token(&self.syntax, T![')'])252	}253}254255#[derive(Debug, Clone, PartialEq, Eq, Hash)]256pub struct ExprLiteral {257	pub(crate) syntax: SyntaxNode,258}259impl ExprLiteral {260	pub fn literal(&self) -> Option<Literal> {261		support::token_child(&self.syntax)262	}263}264265#[derive(Debug, Clone, PartialEq, Eq, Hash)]266pub struct ExprString {267	pub(crate) syntax: SyntaxNode,268}269impl ExprString {270	pub fn text(&self) -> Option<Text> {271		support::token_child(&self.syntax)272	}273}274275#[derive(Debug, Clone, PartialEq, Eq, Hash)]276pub struct ExprNumber {277	pub(crate) syntax: SyntaxNode,278}279impl ExprNumber {280	pub fn number(&self) -> Option<Number> {281		support::token_child(&self.syntax)282	}283}284285#[derive(Debug, Clone, PartialEq, Eq, Hash)]286pub struct ExprArray {287	pub(crate) syntax: SyntaxNode,288}289impl ExprArray {290	pub fn l_brack_token(&self) -> Option<SyntaxToken> {291		support::token(&self.syntax, T!['['])292	}293	pub fn exprs(&self) -> AstChildren<Expr> {294		support::children(&self.syntax)295	}296	pub fn r_brack_token(&self) -> Option<SyntaxToken> {297		support::token(&self.syntax, T![']'])298	}299}300301#[derive(Debug, Clone, PartialEq, Eq, Hash)]302pub struct ExprObject {303	pub(crate) syntax: SyntaxNode,304}305impl ExprObject {306	pub fn obj_body(&self) -> Option<ObjBody> {307		support::children(&self.syntax).next()308	}309}310311#[derive(Debug, Clone, PartialEq, Eq, Hash)]312pub struct ExprArrayComp {313	pub(crate) syntax: SyntaxNode,314}315impl ExprArrayComp {316	pub fn l_brack_token(&self) -> Option<SyntaxToken> {317		support::token(&self.syntax, T!['['])318	}319	pub fn expr(&self) -> Option<Expr> {320		support::children(&self.syntax).next()321	}322	pub fn comma_token(&self) -> Option<SyntaxToken> {323		support::token(&self.syntax, T![,])324	}325	pub fn comp_specs(&self) -> AstChildren<CompSpec> {326		support::children(&self.syntax)327	}328	pub fn r_brack_token(&self) -> Option<SyntaxToken> {329		support::token(&self.syntax, T![']'])330	}331}332333#[derive(Debug, Clone, PartialEq, Eq, Hash)]334pub struct ExprImport {335	pub(crate) syntax: SyntaxNode,336}337impl ExprImport {338	pub fn import_kind(&self) -> Option<ImportKind> {339		support::token_child(&self.syntax)340	}341	pub fn text(&self) -> Option<Text> {342		support::token_child(&self.syntax)343	}344}345346#[derive(Debug, Clone, PartialEq, Eq, Hash)]347pub struct ExprVar {348	pub(crate) syntax: SyntaxNode,349}350impl ExprVar {351	pub fn name(&self) -> Option<Name> {352		support::children(&self.syntax).next()353	}354}355356#[derive(Debug, Clone, PartialEq, Eq, Hash)]357pub struct ExprIfThenElse {358	pub(crate) syntax: SyntaxNode,359}360impl ExprIfThenElse {361	pub fn if_kw_token(&self) -> Option<SyntaxToken> {362		support::token(&self.syntax, T![if])363	}364	pub fn cond(&self) -> Option<Expr> {365		support::children(&self.syntax).next()366	}367	pub fn then_kw_token(&self) -> Option<SyntaxToken> {368		support::token(&self.syntax, T![then])369	}370	pub fn then(&self) -> Option<TrueExpr> {371		support::children(&self.syntax).next()372	}373	pub fn else_kw_token(&self) -> Option<SyntaxToken> {374		support::token(&self.syntax, T![else])375	}376	pub fn else_(&self) -> Option<FalseExpr> {377		support::children(&self.syntax).next()378	}379}380381#[derive(Debug, Clone, PartialEq, Eq, Hash)]382pub struct TrueExpr {383	pub(crate) syntax: SyntaxNode,384}385impl TrueExpr {386	pub fn expr(&self) -> Option<Expr> {387		support::children(&self.syntax).next()388	}389}390391#[derive(Debug, Clone, PartialEq, Eq, Hash)]392pub struct FalseExpr {393	pub(crate) syntax: SyntaxNode,394}395impl FalseExpr {396	pub fn expr(&self) -> Option<Expr> {397		support::children(&self.syntax).next()398	}399}400401#[derive(Debug, Clone, PartialEq, Eq, Hash)]402pub struct ExprFunction {403	pub(crate) syntax: SyntaxNode,404}405impl ExprFunction {406	pub fn function_kw_token(&self) -> Option<SyntaxToken> {407		support::token(&self.syntax, T![function])408	}409	pub fn l_paren_token(&self) -> Option<SyntaxToken> {410		support::token(&self.syntax, T!['('])411	}412	pub fn params_desc(&self) -> Option<ParamsDesc> {413		support::children(&self.syntax).next()414	}415	pub fn r_paren_token(&self) -> Option<SyntaxToken> {416		support::token(&self.syntax, T![')'])417	}418	pub fn expr(&self) -> Option<Expr> {419		support::children(&self.syntax).next()420	}421}422423#[derive(Debug, Clone, PartialEq, Eq, Hash)]424pub struct ParamsDesc {425	pub(crate) syntax: SyntaxNode,426}427impl ParamsDesc {428	pub fn l_paren_token(&self) -> Option<SyntaxToken> {429		support::token(&self.syntax, T!['('])430	}431	pub fn params(&self) -> AstChildren<Param> {432		support::children(&self.syntax)433	}434	pub fn r_paren_token(&self) -> Option<SyntaxToken> {435		support::token(&self.syntax, T![')'])436	}437}438439#[derive(Debug, Clone, PartialEq, Eq, Hash)]440pub struct ExprError {441	pub(crate) syntax: SyntaxNode,442}443impl ExprError {444	pub fn error_kw_token(&self) -> Option<SyntaxToken> {445		support::token(&self.syntax, T![error])446	}447	pub fn expr(&self) -> Option<Expr> {448		support::children(&self.syntax).next()449	}450}451452#[derive(Debug, Clone, PartialEq, Eq, Hash)]453pub struct SliceDescEnd {454	pub(crate) syntax: SyntaxNode,455}456impl SliceDescEnd {457	pub fn expr(&self) -> Option<Expr> {458		support::children(&self.syntax).next()459	}460}461462#[derive(Debug, Clone, PartialEq, Eq, Hash)]463pub struct SliceDescStep {464	pub(crate) syntax: SyntaxNode,465}466impl SliceDescStep {467	pub fn expr(&self) -> Option<Expr> {468		support::children(&self.syntax).next()469	}470}471472#[derive(Debug, Clone, PartialEq, Eq, Hash)]473pub struct Arg {474	pub(crate) syntax: SyntaxNode,475}476impl Arg {477	pub fn name(&self) -> Option<Name> {478		support::children(&self.syntax).next()479	}480	pub fn assign_token(&self) -> Option<SyntaxToken> {481		support::token(&self.syntax, T![=])482	}483	pub fn expr(&self) -> Option<Expr> {484		support::children(&self.syntax).next()485	}486}487488#[derive(Debug, Clone, PartialEq, Eq, Hash)]489pub struct ObjBodyComp {490	pub(crate) syntax: SyntaxNode,491}492impl ObjBodyComp {493	pub fn l_brace_token(&self) -> Option<SyntaxToken> {494		support::token(&self.syntax, T!['{'])495	}496	pub fn member_comps(&self) -> AstChildren<MemberComp> {497		support::children(&self.syntax)498	}499	pub fn comp_specs(&self) -> AstChildren<CompSpec> {500		support::children(&self.syntax)501	}502	pub fn r_brace_token(&self) -> Option<SyntaxToken> {503		support::token(&self.syntax, T!['}'])504	}505}506507#[derive(Debug, Clone, PartialEq, Eq, Hash)]508pub struct ObjBodyMemberList {509	pub(crate) syntax: SyntaxNode,510}511impl ObjBodyMemberList {512	pub fn l_brace_token(&self) -> Option<SyntaxToken> {513		support::token(&self.syntax, T!['{'])514	}515	pub fn members(&self) -> AstChildren<Member> {516		support::children(&self.syntax)517	}518	pub fn r_brace_token(&self) -> Option<SyntaxToken> {519		support::token(&self.syntax, T!['}'])520	}521}522523#[derive(Debug, Clone, PartialEq, Eq, Hash)]524pub struct MemberBindStmt {525	pub(crate) syntax: SyntaxNode,526}527impl MemberBindStmt {528	pub fn obj_local(&self) -> Option<ObjLocal> {529		support::children(&self.syntax).next()530	}531}532533#[derive(Debug, Clone, PartialEq, Eq, Hash)]534pub struct ObjLocal {535	pub(crate) syntax: SyntaxNode,536}537impl ObjLocal {538	pub fn local_kw_token(&self) -> Option<SyntaxToken> {539		support::token(&self.syntax, T![local])540	}541	pub fn bind(&self) -> Option<Bind> {542		support::children(&self.syntax).next()543	}544}545546#[derive(Debug, Clone, PartialEq, Eq, Hash)]547pub struct MemberAssertStmt {548	pub(crate) syntax: SyntaxNode,549}550impl MemberAssertStmt {551	pub fn assertion(&self) -> Option<Assertion> {552		support::children(&self.syntax).next()553	}554}555556#[derive(Debug, Clone, PartialEq, Eq, Hash)]557pub struct MemberFieldNormal {558	pub(crate) syntax: SyntaxNode,559}560impl MemberFieldNormal {561	pub fn field_name(&self) -> Option<FieldName> {562		support::children(&self.syntax).next()563	}564	pub fn plus_token(&self) -> Option<SyntaxToken> {565		support::token(&self.syntax, T![+])566	}567	pub fn visibility(&self) -> Option<Visibility> {568		support::children(&self.syntax).next()569	}570	pub fn expr(&self) -> Option<Expr> {571		support::children(&self.syntax).next()572	}573}574575#[derive(Debug, Clone, PartialEq, Eq, Hash)]576pub struct Visibility {577	pub(crate) syntax: SyntaxNode,578}579impl Visibility {580	pub fn colon_token(&self) -> Option<SyntaxToken> {581		support::token(&self.syntax, T![:])582	}583}584585#[derive(Debug, Clone, PartialEq, Eq, Hash)]586pub struct MemberFieldMethod {587	pub(crate) syntax: SyntaxNode,588}589impl MemberFieldMethod {590	pub fn field_name(&self) -> Option<FieldName> {591		support::children(&self.syntax).next()592	}593	pub fn params_desc(&self) -> Option<ParamsDesc> {594		support::children(&self.syntax).next()595	}596	pub fn visibility(&self) -> Option<Visibility> {597		support::children(&self.syntax).next()598	}599	pub fn expr(&self) -> Option<Expr> {600		support::children(&self.syntax).next()601	}602}603604#[derive(Debug, Clone, PartialEq, Eq, Hash)]605pub struct FieldNameFixed {606	pub(crate) syntax: SyntaxNode,607}608impl FieldNameFixed {609	pub fn id(&self) -> Option<Name> {610		support::children(&self.syntax).next()611	}612	pub fn text(&self) -> Option<Text> {613		support::token_child(&self.syntax)614	}615}616617#[derive(Debug, Clone, PartialEq, Eq, Hash)]618pub struct FieldNameDynamic {619	pub(crate) syntax: SyntaxNode,620}621impl FieldNameDynamic {622	pub fn l_brack_token(&self) -> Option<SyntaxToken> {623		support::token(&self.syntax, T!['['])624	}625	pub fn expr(&self) -> Option<Expr> {626		support::children(&self.syntax).next()627	}628	pub fn r_brack_token(&self) -> Option<SyntaxToken> {629		support::token(&self.syntax, T![']'])630	}631}632633#[derive(Debug, Clone, PartialEq, Eq, Hash)]634pub struct ForSpec {635	pub(crate) syntax: SyntaxNode,636}637impl ForSpec {638	pub fn for_kw_token(&self) -> Option<SyntaxToken> {639		support::token(&self.syntax, T![for])640	}641	pub fn bind(&self) -> Option<Destruct> {642		support::children(&self.syntax).next()643	}644	pub fn in_kw_token(&self) -> Option<SyntaxToken> {645		support::token(&self.syntax, T![in])646	}647	pub fn expr(&self) -> Option<Expr> {648		support::children(&self.syntax).next()649	}650}651652#[derive(Debug, Clone, PartialEq, Eq, Hash)]653pub struct IfSpec {654	pub(crate) syntax: SyntaxNode,655}656impl IfSpec {657	pub fn if_kw_token(&self) -> Option<SyntaxToken> {658		support::token(&self.syntax, T![if])659	}660	pub fn expr(&self) -> Option<Expr> {661		support::children(&self.syntax).next()662	}663}664665#[derive(Debug, Clone, PartialEq, Eq, Hash)]666pub struct BindDestruct {667	pub(crate) syntax: SyntaxNode,668}669impl BindDestruct {670	pub fn into(&self) -> Option<Destruct> {671		support::children(&self.syntax).next()672	}673	pub fn assign_token(&self) -> Option<SyntaxToken> {674		support::token(&self.syntax, T![=])675	}676	pub fn value(&self) -> Option<Expr> {677		support::children(&self.syntax).next()678	}679}680681#[derive(Debug, Clone, PartialEq, Eq, Hash)]682pub struct BindFunction {683	pub(crate) syntax: SyntaxNode,684}685impl BindFunction {686	pub fn name(&self) -> Option<Name> {687		support::children(&self.syntax).next()688	}689	pub fn params(&self) -> Option<ParamsDesc> {690		support::children(&self.syntax).next()691	}692	pub fn assign_token(&self) -> Option<SyntaxToken> {693		support::token(&self.syntax, T![=])694	}695	pub fn value(&self) -> Option<Expr> {696		support::children(&self.syntax).next()697	}698}699700#[derive(Debug, Clone, PartialEq, Eq, Hash)]701pub struct Param {702	pub(crate) syntax: SyntaxNode,703}704impl Param {705	pub fn destruct(&self) -> Option<Destruct> {706		support::children(&self.syntax).next()707	}708	pub fn assign_token(&self) -> Option<SyntaxToken> {709		support::token(&self.syntax, T![=])710	}711	pub fn expr(&self) -> Option<Expr> {712		support::children(&self.syntax).next()713	}714}715716#[derive(Debug, Clone, PartialEq, Eq, Hash)]717pub struct DestructFull {718	pub(crate) syntax: SyntaxNode,719}720impl DestructFull {721	pub fn name(&self) -> Option<Name> {722		support::children(&self.syntax).next()723	}724}725726#[derive(Debug, Clone, PartialEq, Eq, Hash)]727pub struct DestructSkip {728	pub(crate) syntax: SyntaxNode,729}730impl DestructSkip {731	pub fn question_mark_token(&self) -> Option<SyntaxToken> {732		support::token(&self.syntax, T![?])733	}734}735736#[derive(Debug, Clone, PartialEq, Eq, Hash)]737pub struct DestructArray {738	pub(crate) syntax: SyntaxNode,739}740impl DestructArray {741	pub fn l_brack_token(&self) -> Option<SyntaxToken> {742		support::token(&self.syntax, T!['['])743	}744	pub fn destruct_array_parts(&self) -> AstChildren<DestructArrayPart> {745		support::children(&self.syntax)746	}747	pub fn r_brack_token(&self) -> Option<SyntaxToken> {748		support::token(&self.syntax, T![']'])749	}750}751752#[derive(Debug, Clone, PartialEq, Eq, Hash)]753pub struct DestructObject {754	pub(crate) syntax: SyntaxNode,755}756impl DestructObject {757	pub fn l_brace_token(&self) -> Option<SyntaxToken> {758		support::token(&self.syntax, T!['{'])759	}760	pub fn destruct_object_fields(&self) -> AstChildren<DestructObjectField> {761		support::children(&self.syntax)762	}763	pub fn destruct_rest(&self) -> Option<DestructRest> {764		support::children(&self.syntax).next()765	}766	pub fn comma_token(&self) -> Option<SyntaxToken> {767		support::token(&self.syntax, T![,])768	}769	pub fn r_brace_token(&self) -> Option<SyntaxToken> {770		support::token(&self.syntax, T!['}'])771	}772}773774#[derive(Debug, Clone, PartialEq, Eq, Hash)]775pub struct DestructObjectField {776	pub(crate) syntax: SyntaxNode,777}778impl DestructObjectField {779	pub fn field(&self) -> Option<Name> {780		support::children(&self.syntax).next()781	}782	pub fn colon_token(&self) -> Option<SyntaxToken> {783		support::token(&self.syntax, T![:])784	}785	pub fn destruct(&self) -> Option<Destruct> {786		support::children(&self.syntax).next()787	}788	pub fn assign_token(&self) -> Option<SyntaxToken> {789		support::token(&self.syntax, T![=])790	}791	pub fn expr(&self) -> Option<Expr> {792		support::children(&self.syntax).next()793	}794}795796#[derive(Debug, Clone, PartialEq, Eq, Hash)]797pub struct DestructRest {798	pub(crate) syntax: SyntaxNode,799}800impl DestructRest {801	pub fn dotdotdot_token(&self) -> Option<SyntaxToken> {802		support::token(&self.syntax, T![...])803	}804	pub fn into(&self) -> Option<Name> {805		support::children(&self.syntax).next()806	}807}808809#[derive(Debug, Clone, PartialEq, Eq, Hash)]810pub struct DestructArrayElement {811	pub(crate) syntax: SyntaxNode,812}813impl DestructArrayElement {814	pub fn destruct(&self) -> Option<Destruct> {815		support::children(&self.syntax).next()816	}817}818819#[derive(Debug, Clone, PartialEq, Eq, Hash)]820pub enum Suffix {821	SuffixIndex(SuffixIndex),822	SuffixIndexExpr(SuffixIndexExpr),823	SuffixSlice(SuffixSlice),824	SuffixApply(SuffixApply),825}826827#[derive(Debug, Clone, PartialEq, Eq, Hash)]828pub enum Bind {829	BindDestruct(BindDestruct),830	BindFunction(BindFunction),831}832833#[derive(Debug, Clone, PartialEq, Eq, Hash)]834pub enum Stmt {835	StmtLocal(StmtLocal),836	StmtAssert(StmtAssert),837}838839#[derive(Debug, Clone, PartialEq, Eq, Hash)]840pub enum ObjBody {841	ObjBodyComp(ObjBodyComp),842	ObjBodyMemberList(ObjBodyMemberList),843}844845#[derive(Debug, Clone, PartialEq, Eq, Hash)]846pub enum CompSpec {847	ForSpec(ForSpec),848	IfSpec(IfSpec),849}850851#[derive(Debug, Clone, PartialEq, Eq, Hash)]852pub enum ExprBase {853	ExprBinary(ExprBinary),854	ExprUnary(ExprUnary),855	ExprObjExtend(ExprObjExtend),856	ExprParened(ExprParened),857	ExprString(ExprString),858	ExprNumber(ExprNumber),859	ExprLiteral(ExprLiteral),860	ExprArray(ExprArray),861	ExprObject(ExprObject),862	ExprArrayComp(ExprArrayComp),863	ExprImport(ExprImport),864	ExprVar(ExprVar),865	ExprIfThenElse(ExprIfThenElse),866	ExprFunction(ExprFunction),867	ExprError(ExprError),868}869870#[derive(Debug, Clone, PartialEq, Eq, Hash)]871pub enum MemberComp {872	MemberBindStmt(MemberBindStmt),873	MemberFieldNormal(MemberFieldNormal),874	MemberFieldMethod(MemberFieldMethod),875}876877#[derive(Debug, Clone, PartialEq, Eq, Hash)]878pub enum Member {879	MemberBindStmt(MemberBindStmt),880	MemberAssertStmt(MemberAssertStmt),881	MemberFieldNormal(MemberFieldNormal),882	MemberFieldMethod(MemberFieldMethod),883}884885#[derive(Debug, Clone, PartialEq, Eq, Hash)]886pub enum FieldName {887	FieldNameFixed(FieldNameFixed),888	FieldNameDynamic(FieldNameDynamic),889}890891#[derive(Debug, Clone, PartialEq, Eq, Hash)]892pub enum Destruct {893	DestructFull(DestructFull),894	DestructSkip(DestructSkip),895	DestructArray(DestructArray),896	DestructObject(DestructObject),897}898899#[derive(Debug, Clone, PartialEq, Eq, Hash)]900pub enum DestructArrayPart {901	DestructArrayElement(DestructArrayElement),902	DestructRest(DestructRest),903}904905#[derive(Debug, Clone, PartialEq, Eq, Hash)]906pub struct BinaryOperator {907	syntax: SyntaxToken,908	kind: BinaryOperatorKind,909}910911#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]912pub enum BinaryOperatorKind {913	Or,914	NullCoaelse,915	And,916	BitOr,917	BitXor,918	BitAnd,919	Eq,920	Ne,921	Lt,922	Gt,923	Le,924	Ge,925	InKw,926	Lhs,927	Rhs,928	Plus,929	Minus,930	Mul,931	Div,932	Modulo,933	MetaObjectApply,934	ErrorNoOperator,935}936937#[derive(Debug, Clone, PartialEq, Eq, Hash)]938pub struct UnaryOperator {939	syntax: SyntaxToken,940	kind: UnaryOperatorKind,941}942943#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]944pub enum UnaryOperatorKind {945	Minus,946	Not,947	BitNot,948}949950#[derive(Debug, Clone, PartialEq, Eq, Hash)]951pub struct Literal {952	syntax: SyntaxToken,953	kind: LiteralKind,954}955956#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]957pub enum LiteralKind {958	NullKw,959	TrueKw,960	FalseKw,961	SelfKw,962	Dollar,963	SuperKw,964}965966#[derive(Debug, Clone, PartialEq, Eq, Hash)]967pub struct Text {968	syntax: SyntaxToken,969	kind: TextKind,970}971972#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]973pub enum TextKind {974	StringDouble,975	ErrorStringDoubleUnterminated,976	StringSingle,977	ErrorStringSingleUnterminated,978	StringDoubleVerbatim,979	ErrorStringDoubleVerbatimUnterminated,980	StringSingleVerbatim,981	ErrorStringSingleVerbatimUnterminated,982	ErrorStringVerbatimMissingQuotes,983	StringBlock,984	ErrorStringBlockUnexpectedEnd,985	ErrorStringBlockMissingNewLine,986	ErrorStringBlockMissingTermination,987	ErrorStringBlockMissingIndent,988}989990#[derive(Debug, Clone, PartialEq, Eq, Hash)]991pub struct Number {992	syntax: SyntaxToken,993	kind: NumberKind,994}995996#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]997pub enum NumberKind {998	Float,999	ErrorFloatJunkAfterPoint,1000	ErrorFloatJunkAfterExponent,1001	ErrorFloatJunkAfterExponentSign,1002}10031004#[derive(Debug, Clone, PartialEq, Eq, Hash)]1005pub struct ImportKind {1006	syntax: SyntaxToken,1007	kind: ImportKindKind,1008}10091010#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]1011pub enum ImportKindKind {1012	ImportstrKw,1013	ImportbinKw,1014	ImportKw,1015}10161017#[derive(Debug, Clone, PartialEq, Eq, Hash)]1018pub struct Trivia {1019	syntax: SyntaxToken,1020	kind: TriviaKind,1021}10221023#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]1024pub enum TriviaKind {1025	Whitespace,1026	MultiLineComment,1027	ErrorCommentTooShort,1028	ErrorCommentUnterminated,1029	SingleLineHashComment,1030	SingleLineSlashComment,1031}10321033#[derive(Debug, Clone, PartialEq, Eq, Hash)]1034pub struct CustomError {1035	syntax: SyntaxToken,1036	kind: CustomErrorKind,1037}10381039#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]1040pub enum CustomErrorKind {1041	ErrorMissingToken,1042	ErrorUnexpectedToken,1043	ErrorCustom,1044}1045impl AstNode for SourceFile {1046	fn can_cast(kind: SyntaxKind) -> bool {1047		kind == SOURCE_FILE1048	}1049	fn cast(syntax: SyntaxNode) -> Option<Self> {1050		if Self::can_cast(syntax.kind()) {1051			Some(Self { syntax })1052		} else {1053			None1054		}1055	}1056	fn syntax(&self) -> &SyntaxNode {1057		&self.syntax1058	}1059}1060impl AstNode for Expr {1061	fn can_cast(kind: SyntaxKind) -> bool {1062		kind == EXPR1063	}1064	fn cast(syntax: SyntaxNode) -> Option<Self> {1065		if Self::can_cast(syntax.kind()) {1066			Some(Self { syntax })1067		} else {1068			None1069		}1070	}1071	fn syntax(&self) -> &SyntaxNode {1072		&self.syntax1073	}1074}1075impl AstNode for SuffixIndex {1076	fn can_cast(kind: SyntaxKind) -> bool {1077		kind == SUFFIX_INDEX1078	}1079	fn cast(syntax: SyntaxNode) -> Option<Self> {1080		if Self::can_cast(syntax.kind()) {1081			Some(Self { syntax })1082		} else {1083			None1084		}1085	}1086	fn syntax(&self) -> &SyntaxNode {1087		&self.syntax1088	}1089}1090impl AstNode for Name {1091	fn can_cast(kind: SyntaxKind) -> bool {1092		kind == NAME1093	}1094	fn cast(syntax: SyntaxNode) -> Option<Self> {1095		if Self::can_cast(syntax.kind()) {1096			Some(Self { syntax })1097		} else {1098			None1099		}1100	}1101	fn syntax(&self) -> &SyntaxNode {1102		&self.syntax1103	}1104}1105impl AstNode for SuffixIndexExpr {1106	fn can_cast(kind: SyntaxKind) -> bool {1107		kind == SUFFIX_INDEX_EXPR1108	}1109	fn cast(syntax: SyntaxNode) -> Option<Self> {1110		if Self::can_cast(syntax.kind()) {1111			Some(Self { syntax })1112		} else {1113			None1114		}1115	}1116	fn syntax(&self) -> &SyntaxNode {1117		&self.syntax1118	}1119}1120impl AstNode for SuffixSlice {1121	fn can_cast(kind: SyntaxKind) -> bool {1122		kind == SUFFIX_SLICE1123	}1124	fn cast(syntax: SyntaxNode) -> Option<Self> {1125		if Self::can_cast(syntax.kind()) {1126			Some(Self { syntax })1127		} else {1128			None1129		}1130	}1131	fn syntax(&self) -> &SyntaxNode {1132		&self.syntax1133	}1134}1135impl AstNode for SliceDesc {1136	fn can_cast(kind: SyntaxKind) -> bool {1137		kind == SLICE_DESC1138	}1139	fn cast(syntax: SyntaxNode) -> Option<Self> {1140		if Self::can_cast(syntax.kind()) {1141			Some(Self { syntax })1142		} else {1143			None1144		}1145	}1146	fn syntax(&self) -> &SyntaxNode {1147		&self.syntax1148	}1149}1150impl AstNode for SuffixApply {1151	fn can_cast(kind: SyntaxKind) -> bool {1152		kind == SUFFIX_APPLY1153	}1154	fn cast(syntax: SyntaxNode) -> Option<Self> {1155		if Self::can_cast(syntax.kind()) {1156			Some(Self { syntax })1157		} else {1158			None1159		}1160	}1161	fn syntax(&self) -> &SyntaxNode {1162		&self.syntax1163	}1164}1165impl AstNode for ArgsDesc {1166	fn can_cast(kind: SyntaxKind) -> bool {1167		kind == ARGS_DESC1168	}1169	fn cast(syntax: SyntaxNode) -> Option<Self> {1170		if Self::can_cast(syntax.kind()) {1171			Some(Self { syntax })1172		} else {1173			None1174		}1175	}1176	fn syntax(&self) -> &SyntaxNode {1177		&self.syntax1178	}1179}1180impl AstNode for StmtLocal {1181	fn can_cast(kind: SyntaxKind) -> bool {1182		kind == STMT_LOCAL1183	}1184	fn cast(syntax: SyntaxNode) -> Option<Self> {1185		if Self::can_cast(syntax.kind()) {1186			Some(Self { syntax })1187		} else {1188			None1189		}1190	}1191	fn syntax(&self) -> &SyntaxNode {1192		&self.syntax1193	}1194}1195impl AstNode for StmtAssert {1196	fn can_cast(kind: SyntaxKind) -> bool {1197		kind == STMT_ASSERT1198	}1199	fn cast(syntax: SyntaxNode) -> Option<Self> {1200		if Self::can_cast(syntax.kind()) {1201			Some(Self { syntax })1202		} else {1203			None1204		}1205	}1206	fn syntax(&self) -> &SyntaxNode {1207		&self.syntax1208	}1209}1210impl AstNode for Assertion {1211	fn can_cast(kind: SyntaxKind) -> bool {1212		kind == ASSERTION1213	}1214	fn cast(syntax: SyntaxNode) -> Option<Self> {1215		if Self::can_cast(syntax.kind()) {1216			Some(Self { syntax })1217		} else {1218			None1219		}1220	}1221	fn syntax(&self) -> &SyntaxNode {1222		&self.syntax1223	}1224}1225impl AstNode for ExprBinary {1226	fn can_cast(kind: SyntaxKind) -> bool {1227		kind == EXPR_BINARY1228	}1229	fn cast(syntax: SyntaxNode) -> Option<Self> {1230		if Self::can_cast(syntax.kind()) {1231			Some(Self { syntax })1232		} else {1233			None1234		}1235	}1236	fn syntax(&self) -> &SyntaxNode {1237		&self.syntax1238	}1239}1240impl AstNode for ExprUnary {1241	fn can_cast(kind: SyntaxKind) -> bool {1242		kind == EXPR_UNARY1243	}1244	fn cast(syntax: SyntaxNode) -> Option<Self> {1245		if Self::can_cast(syntax.kind()) {1246			Some(Self { syntax })1247		} else {1248			None1249		}1250	}1251	fn syntax(&self) -> &SyntaxNode {1252		&self.syntax1253	}1254}1255impl AstNode for ExprObjExtend {1256	fn can_cast(kind: SyntaxKind) -> bool {1257		kind == EXPR_OBJ_EXTEND1258	}1259	fn cast(syntax: SyntaxNode) -> Option<Self> {1260		if Self::can_cast(syntax.kind()) {1261			Some(Self { syntax })1262		} else {1263			None1264		}1265	}1266	fn syntax(&self) -> &SyntaxNode {1267		&self.syntax1268	}1269}1270impl AstNode for ExprParened {1271	fn can_cast(kind: SyntaxKind) -> bool {1272		kind == EXPR_PARENED1273	}1274	fn cast(syntax: SyntaxNode) -> Option<Self> {1275		if Self::can_cast(syntax.kind()) {1276			Some(Self { syntax })1277		} else {1278			None1279		}1280	}1281	fn syntax(&self) -> &SyntaxNode {1282		&self.syntax1283	}1284}1285impl AstNode for ExprLiteral {1286	fn can_cast(kind: SyntaxKind) -> bool {1287		kind == EXPR_LITERAL1288	}1289	fn cast(syntax: SyntaxNode) -> Option<Self> {1290		if Self::can_cast(syntax.kind()) {1291			Some(Self { syntax })1292		} else {1293			None1294		}1295	}1296	fn syntax(&self) -> &SyntaxNode {1297		&self.syntax1298	}1299}1300impl AstNode for ExprString {1301	fn can_cast(kind: SyntaxKind) -> bool {1302		kind == EXPR_STRING1303	}1304	fn cast(syntax: SyntaxNode) -> Option<Self> {1305		if Self::can_cast(syntax.kind()) {1306			Some(Self { syntax })1307		} else {1308			None1309		}1310	}1311	fn syntax(&self) -> &SyntaxNode {1312		&self.syntax1313	}1314}1315impl AstNode for ExprNumber {1316	fn can_cast(kind: SyntaxKind) -> bool {1317		kind == EXPR_NUMBER1318	}1319	fn cast(syntax: SyntaxNode) -> Option<Self> {1320		if Self::can_cast(syntax.kind()) {1321			Some(Self { syntax })1322		} else {1323			None1324		}1325	}1326	fn syntax(&self) -> &SyntaxNode {1327		&self.syntax1328	}1329}1330impl AstNode for ExprArray {1331	fn can_cast(kind: SyntaxKind) -> bool {1332		kind == EXPR_ARRAY1333	}1334	fn cast(syntax: SyntaxNode) -> Option<Self> {1335		if Self::can_cast(syntax.kind()) {1336			Some(Self { syntax })1337		} else {1338			None1339		}1340	}1341	fn syntax(&self) -> &SyntaxNode {1342		&self.syntax1343	}1344}1345impl AstNode for ExprObject {1346	fn can_cast(kind: SyntaxKind) -> bool {1347		kind == EXPR_OBJECT1348	}1349	fn cast(syntax: SyntaxNode) -> Option<Self> {1350		if Self::can_cast(syntax.kind()) {1351			Some(Self { syntax })1352		} else {1353			None1354		}1355	}1356	fn syntax(&self) -> &SyntaxNode {1357		&self.syntax1358	}1359}1360impl AstNode for ExprArrayComp {1361	fn can_cast(kind: SyntaxKind) -> bool {1362		kind == EXPR_ARRAY_COMP1363	}1364	fn cast(syntax: SyntaxNode) -> Option<Self> {1365		if Self::can_cast(syntax.kind()) {1366			Some(Self { syntax })1367		} else {1368			None1369		}1370	}1371	fn syntax(&self) -> &SyntaxNode {1372		&self.syntax1373	}1374}1375impl AstNode for ExprImport {1376	fn can_cast(kind: SyntaxKind) -> bool {1377		kind == EXPR_IMPORT1378	}1379	fn cast(syntax: SyntaxNode) -> Option<Self> {1380		if Self::can_cast(syntax.kind()) {1381			Some(Self { syntax })1382		} else {1383			None1384		}1385	}1386	fn syntax(&self) -> &SyntaxNode {1387		&self.syntax1388	}1389}1390impl AstNode for ExprVar {1391	fn can_cast(kind: SyntaxKind) -> bool {1392		kind == EXPR_VAR1393	}1394	fn cast(syntax: SyntaxNode) -> Option<Self> {1395		if Self::can_cast(syntax.kind()) {1396			Some(Self { syntax })1397		} else {1398			None1399		}1400	}1401	fn syntax(&self) -> &SyntaxNode {1402		&self.syntax1403	}1404}1405impl AstNode for ExprIfThenElse {1406	fn can_cast(kind: SyntaxKind) -> bool {1407		kind == EXPR_IF_THEN_ELSE1408	}1409	fn cast(syntax: SyntaxNode) -> Option<Self> {1410		if Self::can_cast(syntax.kind()) {1411			Some(Self { syntax })1412		} else {1413			None1414		}1415	}1416	fn syntax(&self) -> &SyntaxNode {1417		&self.syntax1418	}1419}1420impl AstNode for TrueExpr {1421	fn can_cast(kind: SyntaxKind) -> bool {1422		kind == TRUE_EXPR1423	}1424	fn cast(syntax: SyntaxNode) -> Option<Self> {1425		if Self::can_cast(syntax.kind()) {1426			Some(Self { syntax })1427		} else {1428			None1429		}1430	}1431	fn syntax(&self) -> &SyntaxNode {1432		&self.syntax1433	}1434}1435impl AstNode for FalseExpr {1436	fn can_cast(kind: SyntaxKind) -> bool {1437		kind == FALSE_EXPR1438	}1439	fn cast(syntax: SyntaxNode) -> Option<Self> {1440		if Self::can_cast(syntax.kind()) {1441			Some(Self { syntax })1442		} else {1443			None1444		}1445	}1446	fn syntax(&self) -> &SyntaxNode {1447		&self.syntax1448	}1449}1450impl AstNode for ExprFunction {1451	fn can_cast(kind: SyntaxKind) -> bool {1452		kind == EXPR_FUNCTION1453	}1454	fn cast(syntax: SyntaxNode) -> Option<Self> {1455		if Self::can_cast(syntax.kind()) {1456			Some(Self { syntax })1457		} else {1458			None1459		}1460	}1461	fn syntax(&self) -> &SyntaxNode {1462		&self.syntax1463	}1464}1465impl AstNode for ParamsDesc {1466	fn can_cast(kind: SyntaxKind) -> bool {1467		kind == PARAMS_DESC1468	}1469	fn cast(syntax: SyntaxNode) -> Option<Self> {1470		if Self::can_cast(syntax.kind()) {1471			Some(Self { syntax })1472		} else {1473			None1474		}1475	}1476	fn syntax(&self) -> &SyntaxNode {1477		&self.syntax1478	}1479}1480impl AstNode for ExprError {1481	fn can_cast(kind: SyntaxKind) -> bool {1482		kind == EXPR_ERROR1483	}1484	fn cast(syntax: SyntaxNode) -> Option<Self> {1485		if Self::can_cast(syntax.kind()) {1486			Some(Self { syntax })1487		} else {1488			None1489		}1490	}1491	fn syntax(&self) -> &SyntaxNode {1492		&self.syntax1493	}1494}1495impl AstNode for SliceDescEnd {1496	fn can_cast(kind: SyntaxKind) -> bool {1497		kind == SLICE_DESC_END1498	}1499	fn cast(syntax: SyntaxNode) -> Option<Self> {1500		if Self::can_cast(syntax.kind()) {1501			Some(Self { syntax })1502		} else {1503			None1504		}1505	}1506	fn syntax(&self) -> &SyntaxNode {1507		&self.syntax1508	}1509}1510impl AstNode for SliceDescStep {1511	fn can_cast(kind: SyntaxKind) -> bool {1512		kind == SLICE_DESC_STEP1513	}1514	fn cast(syntax: SyntaxNode) -> Option<Self> {1515		if Self::can_cast(syntax.kind()) {1516			Some(Self { syntax })1517		} else {1518			None1519		}1520	}1521	fn syntax(&self) -> &SyntaxNode {1522		&self.syntax1523	}1524}1525impl AstNode for Arg {1526	fn can_cast(kind: SyntaxKind) -> bool {1527		kind == ARG1528	}1529	fn cast(syntax: SyntaxNode) -> Option<Self> {1530		if Self::can_cast(syntax.kind()) {1531			Some(Self { syntax })1532		} else {1533			None1534		}1535	}1536	fn syntax(&self) -> &SyntaxNode {1537		&self.syntax1538	}1539}1540impl AstNode for ObjBodyComp {1541	fn can_cast(kind: SyntaxKind) -> bool {1542		kind == OBJ_BODY_COMP1543	}1544	fn cast(syntax: SyntaxNode) -> Option<Self> {1545		if Self::can_cast(syntax.kind()) {1546			Some(Self { syntax })1547		} else {1548			None1549		}1550	}1551	fn syntax(&self) -> &SyntaxNode {1552		&self.syntax1553	}1554}1555impl AstNode for ObjBodyMemberList {1556	fn can_cast(kind: SyntaxKind) -> bool {1557		kind == OBJ_BODY_MEMBER_LIST1558	}1559	fn cast(syntax: SyntaxNode) -> Option<Self> {1560		if Self::can_cast(syntax.kind()) {1561			Some(Self { syntax })1562		} else {1563			None1564		}1565	}1566	fn syntax(&self) -> &SyntaxNode {1567		&self.syntax1568	}1569}1570impl AstNode for MemberBindStmt {1571	fn can_cast(kind: SyntaxKind) -> bool {1572		kind == MEMBER_BIND_STMT1573	}1574	fn cast(syntax: SyntaxNode) -> Option<Self> {1575		if Self::can_cast(syntax.kind()) {1576			Some(Self { syntax })1577		} else {1578			None1579		}1580	}1581	fn syntax(&self) -> &SyntaxNode {1582		&self.syntax1583	}1584}1585impl AstNode for ObjLocal {1586	fn can_cast(kind: SyntaxKind) -> bool {1587		kind == OBJ_LOCAL1588	}1589	fn cast(syntax: SyntaxNode) -> Option<Self> {1590		if Self::can_cast(syntax.kind()) {1591			Some(Self { syntax })1592		} else {1593			None1594		}1595	}1596	fn syntax(&self) -> &SyntaxNode {1597		&self.syntax1598	}1599}1600impl AstNode for MemberAssertStmt {1601	fn can_cast(kind: SyntaxKind) -> bool {1602		kind == MEMBER_ASSERT_STMT1603	}1604	fn cast(syntax: SyntaxNode) -> Option<Self> {1605		if Self::can_cast(syntax.kind()) {1606			Some(Self { syntax })1607		} else {1608			None1609		}1610	}1611	fn syntax(&self) -> &SyntaxNode {1612		&self.syntax1613	}1614}1615impl AstNode for MemberFieldNormal {1616	fn can_cast(kind: SyntaxKind) -> bool {1617		kind == MEMBER_FIELD_NORMAL1618	}1619	fn cast(syntax: SyntaxNode) -> Option<Self> {1620		if Self::can_cast(syntax.kind()) {1621			Some(Self { syntax })1622		} else {1623			None1624		}1625	}1626	fn syntax(&self) -> &SyntaxNode {1627		&self.syntax1628	}1629}1630impl AstNode for Visibility {1631	fn can_cast(kind: SyntaxKind) -> bool {1632		kind == VISIBILITY1633	}1634	fn cast(syntax: SyntaxNode) -> Option<Self> {1635		if Self::can_cast(syntax.kind()) {1636			Some(Self { syntax })1637		} else {1638			None1639		}1640	}1641	fn syntax(&self) -> &SyntaxNode {1642		&self.syntax1643	}1644}1645impl AstNode for MemberFieldMethod {1646	fn can_cast(kind: SyntaxKind) -> bool {1647		kind == MEMBER_FIELD_METHOD1648	}1649	fn cast(syntax: SyntaxNode) -> Option<Self> {1650		if Self::can_cast(syntax.kind()) {1651			Some(Self { syntax })1652		} else {1653			None1654		}1655	}1656	fn syntax(&self) -> &SyntaxNode {1657		&self.syntax1658	}1659}1660impl AstNode for FieldNameFixed {1661	fn can_cast(kind: SyntaxKind) -> bool {1662		kind == FIELD_NAME_FIXED1663	}1664	fn cast(syntax: SyntaxNode) -> Option<Self> {1665		if Self::can_cast(syntax.kind()) {1666			Some(Self { syntax })1667		} else {1668			None1669		}1670	}1671	fn syntax(&self) -> &SyntaxNode {1672		&self.syntax1673	}1674}1675impl AstNode for FieldNameDynamic {1676	fn can_cast(kind: SyntaxKind) -> bool {1677		kind == FIELD_NAME_DYNAMIC1678	}1679	fn cast(syntax: SyntaxNode) -> Option<Self> {1680		if Self::can_cast(syntax.kind()) {1681			Some(Self { syntax })1682		} else {1683			None1684		}1685	}1686	fn syntax(&self) -> &SyntaxNode {1687		&self.syntax1688	}1689}1690impl AstNode for ForSpec {1691	fn can_cast(kind: SyntaxKind) -> bool {1692		kind == FOR_SPEC1693	}1694	fn cast(syntax: SyntaxNode) -> Option<Self> {1695		if Self::can_cast(syntax.kind()) {1696			Some(Self { syntax })1697		} else {1698			None1699		}1700	}1701	fn syntax(&self) -> &SyntaxNode {1702		&self.syntax1703	}1704}1705impl AstNode for IfSpec {1706	fn can_cast(kind: SyntaxKind) -> bool {1707		kind == IF_SPEC1708	}1709	fn cast(syntax: SyntaxNode) -> Option<Self> {1710		if Self::can_cast(syntax.kind()) {1711			Some(Self { syntax })1712		} else {1713			None1714		}1715	}1716	fn syntax(&self) -> &SyntaxNode {1717		&self.syntax1718	}1719}1720impl AstNode for BindDestruct {1721	fn can_cast(kind: SyntaxKind) -> bool {1722		kind == BIND_DESTRUCT1723	}1724	fn cast(syntax: SyntaxNode) -> Option<Self> {1725		if Self::can_cast(syntax.kind()) {1726			Some(Self { syntax })1727		} else {1728			None1729		}1730	}1731	fn syntax(&self) -> &SyntaxNode {1732		&self.syntax1733	}1734}1735impl AstNode for BindFunction {1736	fn can_cast(kind: SyntaxKind) -> bool {1737		kind == BIND_FUNCTION1738	}1739	fn cast(syntax: SyntaxNode) -> Option<Self> {1740		if Self::can_cast(syntax.kind()) {1741			Some(Self { syntax })1742		} else {1743			None1744		}1745	}1746	fn syntax(&self) -> &SyntaxNode {1747		&self.syntax1748	}1749}1750impl AstNode for Param {1751	fn can_cast(kind: SyntaxKind) -> bool {1752		kind == PARAM1753	}1754	fn cast(syntax: SyntaxNode) -> Option<Self> {1755		if Self::can_cast(syntax.kind()) {1756			Some(Self { syntax })1757		} else {1758			None1759		}1760	}1761	fn syntax(&self) -> &SyntaxNode {1762		&self.syntax1763	}1764}1765impl AstNode for DestructFull {1766	fn can_cast(kind: SyntaxKind) -> bool {1767		kind == DESTRUCT_FULL1768	}1769	fn cast(syntax: SyntaxNode) -> Option<Self> {1770		if Self::can_cast(syntax.kind()) {1771			Some(Self { syntax })1772		} else {1773			None1774		}1775	}1776	fn syntax(&self) -> &SyntaxNode {1777		&self.syntax1778	}1779}1780impl AstNode for DestructSkip {1781	fn can_cast(kind: SyntaxKind) -> bool {1782		kind == DESTRUCT_SKIP1783	}1784	fn cast(syntax: SyntaxNode) -> Option<Self> {1785		if Self::can_cast(syntax.kind()) {1786			Some(Self { syntax })1787		} else {1788			None1789		}1790	}1791	fn syntax(&self) -> &SyntaxNode {1792		&self.syntax1793	}1794}1795impl AstNode for DestructArray {1796	fn can_cast(kind: SyntaxKind) -> bool {1797		kind == DESTRUCT_ARRAY1798	}1799	fn cast(syntax: SyntaxNode) -> Option<Self> {1800		if Self::can_cast(syntax.kind()) {1801			Some(Self { syntax })1802		} else {1803			None1804		}1805	}1806	fn syntax(&self) -> &SyntaxNode {1807		&self.syntax1808	}1809}1810impl AstNode for DestructObject {1811	fn can_cast(kind: SyntaxKind) -> bool {1812		kind == DESTRUCT_OBJECT1813	}1814	fn cast(syntax: SyntaxNode) -> Option<Self> {1815		if Self::can_cast(syntax.kind()) {1816			Some(Self { syntax })1817		} else {1818			None1819		}1820	}1821	fn syntax(&self) -> &SyntaxNode {1822		&self.syntax1823	}1824}1825impl AstNode for DestructObjectField {1826	fn can_cast(kind: SyntaxKind) -> bool {1827		kind == DESTRUCT_OBJECT_FIELD1828	}1829	fn cast(syntax: SyntaxNode) -> Option<Self> {1830		if Self::can_cast(syntax.kind()) {1831			Some(Self { syntax })1832		} else {1833			None1834		}1835	}1836	fn syntax(&self) -> &SyntaxNode {1837		&self.syntax1838	}1839}1840impl AstNode for DestructRest {1841	fn can_cast(kind: SyntaxKind) -> bool {1842		kind == DESTRUCT_REST1843	}1844	fn cast(syntax: SyntaxNode) -> Option<Self> {1845		if Self::can_cast(syntax.kind()) {1846			Some(Self { syntax })1847		} else {1848			None1849		}1850	}1851	fn syntax(&self) -> &SyntaxNode {1852		&self.syntax1853	}1854}1855impl AstNode for DestructArrayElement {1856	fn can_cast(kind: SyntaxKind) -> bool {1857		kind == DESTRUCT_ARRAY_ELEMENT1858	}1859	fn cast(syntax: SyntaxNode) -> Option<Self> {1860		if Self::can_cast(syntax.kind()) {1861			Some(Self { syntax })1862		} else {1863			None1864		}1865	}1866	fn syntax(&self) -> &SyntaxNode {1867		&self.syntax1868	}1869}1870impl From<SuffixIndex> for Suffix {1871	fn from(node: SuffixIndex) -> Suffix {1872		Suffix::SuffixIndex(node)1873	}1874}1875impl From<SuffixIndexExpr> for Suffix {1876	fn from(node: SuffixIndexExpr) -> Suffix {1877		Suffix::SuffixIndexExpr(node)1878	}1879}1880impl From<SuffixSlice> for Suffix {1881	fn from(node: SuffixSlice) -> Suffix {1882		Suffix::SuffixSlice(node)1883	}1884}1885impl From<SuffixApply> for Suffix {1886	fn from(node: SuffixApply) -> Suffix {1887		Suffix::SuffixApply(node)1888	}1889}1890impl AstNode for Suffix {1891	fn can_cast(kind: SyntaxKind) -> bool {1892		match kind {1893			SUFFIX_INDEX | SUFFIX_INDEX_EXPR | SUFFIX_SLICE | SUFFIX_APPLY => true,1894			_ => false,1895		}1896	}1897	fn cast(syntax: SyntaxNode) -> Option<Self> {1898		let res = match syntax.kind() {1899			SUFFIX_INDEX => Suffix::SuffixIndex(SuffixIndex { syntax }),1900			SUFFIX_INDEX_EXPR => Suffix::SuffixIndexExpr(SuffixIndexExpr { syntax }),1901			SUFFIX_SLICE => Suffix::SuffixSlice(SuffixSlice { syntax }),1902			SUFFIX_APPLY => Suffix::SuffixApply(SuffixApply { syntax }),1903			_ => return None,1904		};1905		Some(res)1906	}1907	fn syntax(&self) -> &SyntaxNode {1908		match self {1909			Suffix::SuffixIndex(it) => &it.syntax,1910			Suffix::SuffixIndexExpr(it) => &it.syntax,1911			Suffix::SuffixSlice(it) => &it.syntax,1912			Suffix::SuffixApply(it) => &it.syntax,1913		}1914	}1915}1916impl From<BindDestruct> for Bind {1917	fn from(node: BindDestruct) -> Bind {1918		Bind::BindDestruct(node)1919	}1920}1921impl From<BindFunction> for Bind {1922	fn from(node: BindFunction) -> Bind {1923		Bind::BindFunction(node)1924	}1925}1926impl AstNode for Bind {1927	fn can_cast(kind: SyntaxKind) -> bool {1928		match kind {1929			BIND_DESTRUCT | BIND_FUNCTION => true,1930			_ => false,1931		}1932	}1933	fn cast(syntax: SyntaxNode) -> Option<Self> {1934		let res = match syntax.kind() {1935			BIND_DESTRUCT => Bind::BindDestruct(BindDestruct { syntax }),1936			BIND_FUNCTION => Bind::BindFunction(BindFunction { syntax }),1937			_ => return None,1938		};1939		Some(res)1940	}1941	fn syntax(&self) -> &SyntaxNode {1942		match self {1943			Bind::BindDestruct(it) => &it.syntax,1944			Bind::BindFunction(it) => &it.syntax,1945		}1946	}1947}1948impl From<StmtLocal> for Stmt {1949	fn from(node: StmtLocal) -> Stmt {1950		Stmt::StmtLocal(node)1951	}1952}1953impl From<StmtAssert> for Stmt {1954	fn from(node: StmtAssert) -> Stmt {1955		Stmt::StmtAssert(node)1956	}1957}1958impl AstNode for Stmt {1959	fn can_cast(kind: SyntaxKind) -> bool {1960		match kind {1961			STMT_LOCAL | STMT_ASSERT => true,1962			_ => false,1963		}1964	}1965	fn cast(syntax: SyntaxNode) -> Option<Self> {1966		let res = match syntax.kind() {1967			STMT_LOCAL => Stmt::StmtLocal(StmtLocal { syntax }),1968			STMT_ASSERT => Stmt::StmtAssert(StmtAssert { syntax }),1969			_ => return None,1970		};1971		Some(res)1972	}1973	fn syntax(&self) -> &SyntaxNode {1974		match self {1975			Stmt::StmtLocal(it) => &it.syntax,1976			Stmt::StmtAssert(it) => &it.syntax,1977		}1978	}1979}1980impl From<ObjBodyComp> for ObjBody {1981	fn from(node: ObjBodyComp) -> ObjBody {1982		ObjBody::ObjBodyComp(node)1983	}1984}1985impl From<ObjBodyMemberList> for ObjBody {1986	fn from(node: ObjBodyMemberList) -> ObjBody {1987		ObjBody::ObjBodyMemberList(node)1988	}1989}1990impl AstNode for ObjBody {1991	fn can_cast(kind: SyntaxKind) -> bool {1992		match kind {1993			OBJ_BODY_COMP | OBJ_BODY_MEMBER_LIST => true,1994			_ => false,1995		}1996	}1997	fn cast(syntax: SyntaxNode) -> Option<Self> {1998		let res = match syntax.kind() {1999			OBJ_BODY_COMP => ObjBody::ObjBodyComp(ObjBodyComp { syntax }),2000			OBJ_BODY_MEMBER_LIST => ObjBody::ObjBodyMemberList(ObjBodyMemberList { syntax }),2001			_ => return None,2002		};2003		Some(res)2004	}2005	fn syntax(&self) -> &SyntaxNode {2006		match self {2007			ObjBody::ObjBodyComp(it) => &it.syntax,2008			ObjBody::ObjBodyMemberList(it) => &it.syntax,2009		}2010	}2011}2012impl From<ForSpec> for CompSpec {2013	fn from(node: ForSpec) -> CompSpec {2014		CompSpec::ForSpec(node)2015	}2016}2017impl From<IfSpec> for CompSpec {2018	fn from(node: IfSpec) -> CompSpec {2019		CompSpec::IfSpec(node)2020	}2021}2022impl AstNode for CompSpec {2023	fn can_cast(kind: SyntaxKind) -> bool {2024		match kind {2025			FOR_SPEC | IF_SPEC => true,2026			_ => false,2027		}2028	}2029	fn cast(syntax: SyntaxNode) -> Option<Self> {2030		let res = match syntax.kind() {2031			FOR_SPEC => CompSpec::ForSpec(ForSpec { syntax }),2032			IF_SPEC => CompSpec::IfSpec(IfSpec { syntax }),2033			_ => return None,2034		};2035		Some(res)2036	}2037	fn syntax(&self) -> &SyntaxNode {2038		match self {2039			CompSpec::ForSpec(it) => &it.syntax,2040			CompSpec::IfSpec(it) => &it.syntax,2041		}2042	}2043}2044impl From<ExprBinary> for ExprBase {2045	fn from(node: ExprBinary) -> ExprBase {2046		ExprBase::ExprBinary(node)2047	}2048}2049impl From<ExprUnary> for ExprBase {2050	fn from(node: ExprUnary) -> ExprBase {2051		ExprBase::ExprUnary(node)2052	}2053}2054impl From<ExprObjExtend> for ExprBase {2055	fn from(node: ExprObjExtend) -> ExprBase {2056		ExprBase::ExprObjExtend(node)2057	}2058}2059impl From<ExprParened> for ExprBase {2060	fn from(node: ExprParened) -> ExprBase {2061		ExprBase::ExprParened(node)2062	}2063}2064impl From<ExprString> for ExprBase {2065	fn from(node: ExprString) -> ExprBase {2066		ExprBase::ExprString(node)2067	}2068}2069impl From<ExprNumber> for ExprBase {2070	fn from(node: ExprNumber) -> ExprBase {2071		ExprBase::ExprNumber(node)2072	}2073}2074impl From<ExprLiteral> for ExprBase {2075	fn from(node: ExprLiteral) -> ExprBase {2076		ExprBase::ExprLiteral(node)2077	}2078}2079impl From<ExprArray> for ExprBase {2080	fn from(node: ExprArray) -> ExprBase {2081		ExprBase::ExprArray(node)2082	}2083}2084impl From<ExprObject> for ExprBase {2085	fn from(node: ExprObject) -> ExprBase {2086		ExprBase::ExprObject(node)2087	}2088}2089impl From<ExprArrayComp> for ExprBase {2090	fn from(node: ExprArrayComp) -> ExprBase {2091		ExprBase::ExprArrayComp(node)2092	}2093}2094impl From<ExprImport> for ExprBase {2095	fn from(node: ExprImport) -> ExprBase {2096		ExprBase::ExprImport(node)2097	}2098}2099impl From<ExprVar> for ExprBase {2100	fn from(node: ExprVar) -> ExprBase {2101		ExprBase::ExprVar(node)2102	}2103}2104impl From<ExprIfThenElse> for ExprBase {2105	fn from(node: ExprIfThenElse) -> ExprBase {2106		ExprBase::ExprIfThenElse(node)2107	}2108}2109impl From<ExprFunction> for ExprBase {2110	fn from(node: ExprFunction) -> ExprBase {2111		ExprBase::ExprFunction(node)2112	}2113}2114impl From<ExprError> for ExprBase {2115	fn from(node: ExprError) -> ExprBase {2116		ExprBase::ExprError(node)2117	}2118}2119impl AstNode for ExprBase {2120	fn can_cast(kind: SyntaxKind) -> bool {2121		match kind {2122			EXPR_BINARY | EXPR_UNARY | EXPR_OBJ_EXTEND | EXPR_PARENED | EXPR_STRING2123			| EXPR_NUMBER | EXPR_LITERAL | EXPR_ARRAY | EXPR_OBJECT | EXPR_ARRAY_COMP2124			| EXPR_IMPORT | EXPR_VAR | EXPR_IF_THEN_ELSE | EXPR_FUNCTION | EXPR_ERROR => true,2125			_ => false,2126		}2127	}2128	fn cast(syntax: SyntaxNode) -> Option<Self> {2129		let res = match syntax.kind() {2130			EXPR_BINARY => ExprBase::ExprBinary(ExprBinary { syntax }),2131			EXPR_UNARY => ExprBase::ExprUnary(ExprUnary { syntax }),2132			EXPR_OBJ_EXTEND => ExprBase::ExprObjExtend(ExprObjExtend { syntax }),2133			EXPR_PARENED => ExprBase::ExprParened(ExprParened { syntax }),2134			EXPR_STRING => ExprBase::ExprString(ExprString { syntax }),2135			EXPR_NUMBER => ExprBase::ExprNumber(ExprNumber { syntax }),2136			EXPR_LITERAL => ExprBase::ExprLiteral(ExprLiteral { syntax }),2137			EXPR_ARRAY => ExprBase::ExprArray(ExprArray { syntax }),2138			EXPR_OBJECT => ExprBase::ExprObject(ExprObject { syntax }),2139			EXPR_ARRAY_COMP => ExprBase::ExprArrayComp(ExprArrayComp { syntax }),2140			EXPR_IMPORT => ExprBase::ExprImport(ExprImport { syntax }),2141			EXPR_VAR => ExprBase::ExprVar(ExprVar { syntax }),2142			EXPR_IF_THEN_ELSE => ExprBase::ExprIfThenElse(ExprIfThenElse { syntax }),2143			EXPR_FUNCTION => ExprBase::ExprFunction(ExprFunction { syntax }),2144			EXPR_ERROR => ExprBase::ExprError(ExprError { syntax }),2145			_ => return None,2146		};2147		Some(res)2148	}2149	fn syntax(&self) -> &SyntaxNode {2150		match self {2151			ExprBase::ExprBinary(it) => &it.syntax,2152			ExprBase::ExprUnary(it) => &it.syntax,2153			ExprBase::ExprObjExtend(it) => &it.syntax,2154			ExprBase::ExprParened(it) => &it.syntax,2155			ExprBase::ExprString(it) => &it.syntax,2156			ExprBase::ExprNumber(it) => &it.syntax,2157			ExprBase::ExprLiteral(it) => &it.syntax,2158			ExprBase::ExprArray(it) => &it.syntax,2159			ExprBase::ExprObject(it) => &it.syntax,2160			ExprBase::ExprArrayComp(it) => &it.syntax,2161			ExprBase::ExprImport(it) => &it.syntax,2162			ExprBase::ExprVar(it) => &it.syntax,2163			ExprBase::ExprIfThenElse(it) => &it.syntax,2164			ExprBase::ExprFunction(it) => &it.syntax,2165			ExprBase::ExprError(it) => &it.syntax,2166		}2167	}2168}2169impl From<MemberBindStmt> for MemberComp {2170	fn from(node: MemberBindStmt) -> MemberComp {2171		MemberComp::MemberBindStmt(node)2172	}2173}2174impl From<MemberFieldNormal> for MemberComp {2175	fn from(node: MemberFieldNormal) -> MemberComp {2176		MemberComp::MemberFieldNormal(node)2177	}2178}2179impl From<MemberFieldMethod> for MemberComp {2180	fn from(node: MemberFieldMethod) -> MemberComp {2181		MemberComp::MemberFieldMethod(node)2182	}2183}2184impl AstNode for MemberComp {2185	fn can_cast(kind: SyntaxKind) -> bool {2186		match kind {2187			MEMBER_BIND_STMT | MEMBER_FIELD_NORMAL | MEMBER_FIELD_METHOD => true,2188			_ => false,2189		}2190	}2191	fn cast(syntax: SyntaxNode) -> Option<Self> {2192		let res = match syntax.kind() {2193			MEMBER_BIND_STMT => MemberComp::MemberBindStmt(MemberBindStmt { syntax }),2194			MEMBER_FIELD_NORMAL => MemberComp::MemberFieldNormal(MemberFieldNormal { syntax }),2195			MEMBER_FIELD_METHOD => MemberComp::MemberFieldMethod(MemberFieldMethod { syntax }),2196			_ => return None,2197		};2198		Some(res)2199	}2200	fn syntax(&self) -> &SyntaxNode {2201		match self {2202			MemberComp::MemberBindStmt(it) => &it.syntax,2203			MemberComp::MemberFieldNormal(it) => &it.syntax,2204			MemberComp::MemberFieldMethod(it) => &it.syntax,2205		}2206	}2207}2208impl From<MemberBindStmt> for Member {2209	fn from(node: MemberBindStmt) -> Member {2210		Member::MemberBindStmt(node)2211	}2212}2213impl From<MemberAssertStmt> for Member {2214	fn from(node: MemberAssertStmt) -> Member {2215		Member::MemberAssertStmt(node)2216	}2217}2218impl From<MemberFieldNormal> for Member {2219	fn from(node: MemberFieldNormal) -> Member {2220		Member::MemberFieldNormal(node)2221	}2222}2223impl From<MemberFieldMethod> for Member {2224	fn from(node: MemberFieldMethod) -> Member {2225		Member::MemberFieldMethod(node)2226	}2227}2228impl AstNode for Member {2229	fn can_cast(kind: SyntaxKind) -> bool {2230		match kind {2231			MEMBER_BIND_STMT | MEMBER_ASSERT_STMT | MEMBER_FIELD_NORMAL | MEMBER_FIELD_METHOD => {2232				true2233			}2234			_ => false,2235		}2236	}2237	fn cast(syntax: SyntaxNode) -> Option<Self> {2238		let res = match syntax.kind() {2239			MEMBER_BIND_STMT => Member::MemberBindStmt(MemberBindStmt { syntax }),2240			MEMBER_ASSERT_STMT => Member::MemberAssertStmt(MemberAssertStmt { syntax }),2241			MEMBER_FIELD_NORMAL => Member::MemberFieldNormal(MemberFieldNormal { syntax }),2242			MEMBER_FIELD_METHOD => Member::MemberFieldMethod(MemberFieldMethod { syntax }),2243			_ => return None,2244		};2245		Some(res)2246	}2247	fn syntax(&self) -> &SyntaxNode {2248		match self {2249			Member::MemberBindStmt(it) => &it.syntax,2250			Member::MemberAssertStmt(it) => &it.syntax,2251			Member::MemberFieldNormal(it) => &it.syntax,2252			Member::MemberFieldMethod(it) => &it.syntax,2253		}2254	}2255}2256impl From<FieldNameFixed> for FieldName {2257	fn from(node: FieldNameFixed) -> FieldName {2258		FieldName::FieldNameFixed(node)2259	}2260}2261impl From<FieldNameDynamic> for FieldName {2262	fn from(node: FieldNameDynamic) -> FieldName {2263		FieldName::FieldNameDynamic(node)2264	}2265}2266impl AstNode for FieldName {2267	fn can_cast(kind: SyntaxKind) -> bool {2268		match kind {2269			FIELD_NAME_FIXED | FIELD_NAME_DYNAMIC => true,2270			_ => false,2271		}2272	}2273	fn cast(syntax: SyntaxNode) -> Option<Self> {2274		let res = match syntax.kind() {2275			FIELD_NAME_FIXED => FieldName::FieldNameFixed(FieldNameFixed { syntax }),2276			FIELD_NAME_DYNAMIC => FieldName::FieldNameDynamic(FieldNameDynamic { syntax }),2277			_ => return None,2278		};2279		Some(res)2280	}2281	fn syntax(&self) -> &SyntaxNode {2282		match self {2283			FieldName::FieldNameFixed(it) => &it.syntax,2284			FieldName::FieldNameDynamic(it) => &it.syntax,2285		}2286	}2287}2288impl From<DestructFull> for Destruct {2289	fn from(node: DestructFull) -> Destruct {2290		Destruct::DestructFull(node)2291	}2292}2293impl From<DestructSkip> for Destruct {2294	fn from(node: DestructSkip) -> Destruct {2295		Destruct::DestructSkip(node)2296	}2297}2298impl From<DestructArray> for Destruct {2299	fn from(node: DestructArray) -> Destruct {2300		Destruct::DestructArray(node)2301	}2302}2303impl From<DestructObject> for Destruct {2304	fn from(node: DestructObject) -> Destruct {2305		Destruct::DestructObject(node)2306	}2307}2308impl AstNode for Destruct {2309	fn can_cast(kind: SyntaxKind) -> bool {2310		match kind {2311			DESTRUCT_FULL | DESTRUCT_SKIP | DESTRUCT_ARRAY | DESTRUCT_OBJECT => true,2312			_ => false,2313		}2314	}2315	fn cast(syntax: SyntaxNode) -> Option<Self> {2316		let res = match syntax.kind() {2317			DESTRUCT_FULL => Destruct::DestructFull(DestructFull { syntax }),2318			DESTRUCT_SKIP => Destruct::DestructSkip(DestructSkip { syntax }),2319			DESTRUCT_ARRAY => Destruct::DestructArray(DestructArray { syntax }),2320			DESTRUCT_OBJECT => Destruct::DestructObject(DestructObject { syntax }),2321			_ => return None,2322		};2323		Some(res)2324	}2325	fn syntax(&self) -> &SyntaxNode {2326		match self {2327			Destruct::DestructFull(it) => &it.syntax,2328			Destruct::DestructSkip(it) => &it.syntax,2329			Destruct::DestructArray(it) => &it.syntax,2330			Destruct::DestructObject(it) => &it.syntax,2331		}2332	}2333}2334impl From<DestructArrayElement> for DestructArrayPart {2335	fn from(node: DestructArrayElement) -> DestructArrayPart {2336		DestructArrayPart::DestructArrayElement(node)2337	}2338}2339impl From<DestructRest> for DestructArrayPart {2340	fn from(node: DestructRest) -> DestructArrayPart {2341		DestructArrayPart::DestructRest(node)2342	}2343}2344impl AstNode for DestructArrayPart {2345	fn can_cast(kind: SyntaxKind) -> bool {2346		match kind {2347			DESTRUCT_ARRAY_ELEMENT | DESTRUCT_REST => true,2348			_ => false,2349		}2350	}2351	fn cast(syntax: SyntaxNode) -> Option<Self> {2352		let res = match syntax.kind() {2353			DESTRUCT_ARRAY_ELEMENT => {2354				DestructArrayPart::DestructArrayElement(DestructArrayElement { syntax })2355			}2356			DESTRUCT_REST => DestructArrayPart::DestructRest(DestructRest { syntax }),2357			_ => return None,2358		};2359		Some(res)2360	}2361	fn syntax(&self) -> &SyntaxNode {2362		match self {2363			DestructArrayPart::DestructArrayElement(it) => &it.syntax,2364			DestructArrayPart::DestructRest(it) => &it.syntax,2365		}2366	}2367}2368impl AstToken for BinaryOperator {2369	fn can_cast(kind: SyntaxKind) -> bool {2370		BinaryOperatorKind::can_cast(kind)2371	}2372	fn cast(syntax: SyntaxToken) -> Option<Self> {2373		let kind = BinaryOperatorKind::cast(syntax.kind())?;2374		Some(BinaryOperator { syntax, kind })2375	}2376	fn syntax(&self) -> &SyntaxToken {2377		&self.syntax2378	}2379}2380impl BinaryOperatorKind {2381	fn can_cast(kind: SyntaxKind) -> bool {2382		match kind {2383			OR | NULL_COAELSE | AND | BIT_OR | BIT_XOR | BIT_AND | EQ | NE | LT | GT | LE | GE2384			| IN_KW | LHS | RHS | PLUS | MINUS | MUL | DIV | MODULO | META_OBJECT_APPLY2385			| ERROR_NO_OPERATOR => true,2386			_ => false,2387		}2388	}2389	pub fn cast(kind: SyntaxKind) -> Option<Self> {2390		let res = match kind {2391			OR => Self::Or,2392			NULL_COAELSE => Self::NullCoaelse,2393			AND => Self::And,2394			BIT_OR => Self::BitOr,2395			BIT_XOR => Self::BitXor,2396			BIT_AND => Self::BitAnd,2397			EQ => Self::Eq,2398			NE => Self::Ne,2399			LT => Self::Lt,2400			GT => Self::Gt,2401			LE => Self::Le,2402			GE => Self::Ge,2403			IN_KW => Self::InKw,2404			LHS => Self::Lhs,2405			RHS => Self::Rhs,2406			PLUS => Self::Plus,2407			MINUS => Self::Minus,2408			MUL => Self::Mul,2409			DIV => Self::Div,2410			MODULO => Self::Modulo,2411			META_OBJECT_APPLY => Self::MetaObjectApply,2412			ERROR_NO_OPERATOR => Self::ErrorNoOperator,2413			_ => return None,2414		};2415		Some(res)2416	}2417}2418impl BinaryOperator {2419	pub fn kind(&self) -> BinaryOperatorKind {2420		self.kind2421	}2422}2423impl std::fmt::Display for BinaryOperator {2424	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2425		std::fmt::Display::fmt(self.syntax(), f)2426	}2427}2428impl AstToken for UnaryOperator {2429	fn can_cast(kind: SyntaxKind) -> bool {2430		UnaryOperatorKind::can_cast(kind)2431	}2432	fn cast(syntax: SyntaxToken) -> Option<Self> {2433		let kind = UnaryOperatorKind::cast(syntax.kind())?;2434		Some(UnaryOperator { syntax, kind })2435	}2436	fn syntax(&self) -> &SyntaxToken {2437		&self.syntax2438	}2439}2440impl UnaryOperatorKind {2441	fn can_cast(kind: SyntaxKind) -> bool {2442		match kind {2443			MINUS | NOT | BIT_NOT => true,2444			_ => false,2445		}2446	}2447	pub fn cast(kind: SyntaxKind) -> Option<Self> {2448		let res = match kind {2449			MINUS => Self::Minus,2450			NOT => Self::Not,2451			BIT_NOT => Self::BitNot,2452			_ => return None,2453		};2454		Some(res)2455	}2456}2457impl UnaryOperator {2458	pub fn kind(&self) -> UnaryOperatorKind {2459		self.kind2460	}2461}2462impl std::fmt::Display for UnaryOperator {2463	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2464		std::fmt::Display::fmt(self.syntax(), f)2465	}2466}2467impl AstToken for Literal {2468	fn can_cast(kind: SyntaxKind) -> bool {2469		LiteralKind::can_cast(kind)2470	}2471	fn cast(syntax: SyntaxToken) -> Option<Self> {2472		let kind = LiteralKind::cast(syntax.kind())?;2473		Some(Literal { syntax, kind })2474	}2475	fn syntax(&self) -> &SyntaxToken {2476		&self.syntax2477	}2478}2479impl LiteralKind {2480	fn can_cast(kind: SyntaxKind) -> bool {2481		match kind {2482			NULL_KW | TRUE_KW | FALSE_KW | SELF_KW | DOLLAR | SUPER_KW => true,2483			_ => false,2484		}2485	}2486	pub fn cast(kind: SyntaxKind) -> Option<Self> {2487		let res = match kind {2488			NULL_KW => Self::NullKw,2489			TRUE_KW => Self::TrueKw,2490			FALSE_KW => Self::FalseKw,2491			SELF_KW => Self::SelfKw,2492			DOLLAR => Self::Dollar,2493			SUPER_KW => Self::SuperKw,2494			_ => return None,2495		};2496		Some(res)2497	}2498}2499impl Literal {2500	pub fn kind(&self) -> LiteralKind {2501		self.kind2502	}2503}2504impl std::fmt::Display for Literal {2505	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2506		std::fmt::Display::fmt(self.syntax(), f)2507	}2508}2509impl AstToken for Text {2510	fn can_cast(kind: SyntaxKind) -> bool {2511		TextKind::can_cast(kind)2512	}2513	fn cast(syntax: SyntaxToken) -> Option<Self> {2514		let kind = TextKind::cast(syntax.kind())?;2515		Some(Text { syntax, kind })2516	}2517	fn syntax(&self) -> &SyntaxToken {2518		&self.syntax2519	}2520}2521impl TextKind {2522	fn can_cast(kind: SyntaxKind) -> bool {2523		match kind {2524			STRING_DOUBLE2525			| ERROR_STRING_DOUBLE_UNTERMINATED2526			| STRING_SINGLE2527			| ERROR_STRING_SINGLE_UNTERMINATED2528			| STRING_DOUBLE_VERBATIM2529			| ERROR_STRING_DOUBLE_VERBATIM_UNTERMINATED2530			| STRING_SINGLE_VERBATIM2531			| ERROR_STRING_SINGLE_VERBATIM_UNTERMINATED2532			| ERROR_STRING_VERBATIM_MISSING_QUOTES2533			| STRING_BLOCK2534			| ERROR_STRING_BLOCK_UNEXPECTED_END2535			| ERROR_STRING_BLOCK_MISSING_NEW_LINE2536			| ERROR_STRING_BLOCK_MISSING_TERMINATION2537			| ERROR_STRING_BLOCK_MISSING_INDENT => true,2538			_ => false,2539		}2540	}2541	pub fn cast(kind: SyntaxKind) -> Option<Self> {2542		let res = match kind {2543			STRING_DOUBLE => Self::StringDouble,2544			ERROR_STRING_DOUBLE_UNTERMINATED => Self::ErrorStringDoubleUnterminated,2545			STRING_SINGLE => Self::StringSingle,2546			ERROR_STRING_SINGLE_UNTERMINATED => Self::ErrorStringSingleUnterminated,2547			STRING_DOUBLE_VERBATIM => Self::StringDoubleVerbatim,2548			ERROR_STRING_DOUBLE_VERBATIM_UNTERMINATED => {2549				Self::ErrorStringDoubleVerbatimUnterminated2550			}2551			STRING_SINGLE_VERBATIM => Self::StringSingleVerbatim,2552			ERROR_STRING_SINGLE_VERBATIM_UNTERMINATED => {2553				Self::ErrorStringSingleVerbatimUnterminated2554			}2555			ERROR_STRING_VERBATIM_MISSING_QUOTES => Self::ErrorStringVerbatimMissingQuotes,2556			STRING_BLOCK => Self::StringBlock,2557			ERROR_STRING_BLOCK_UNEXPECTED_END => Self::ErrorStringBlockUnexpectedEnd,2558			ERROR_STRING_BLOCK_MISSING_NEW_LINE => Self::ErrorStringBlockMissingNewLine,2559			ERROR_STRING_BLOCK_MISSING_TERMINATION => Self::ErrorStringBlockMissingTermination,2560			ERROR_STRING_BLOCK_MISSING_INDENT => Self::ErrorStringBlockMissingIndent,2561			_ => return None,2562		};2563		Some(res)2564	}2565}2566impl Text {2567	pub fn kind(&self) -> TextKind {2568		self.kind2569	}2570}2571impl std::fmt::Display for Text {2572	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2573		std::fmt::Display::fmt(self.syntax(), f)2574	}2575}2576impl AstToken for Number {2577	fn can_cast(kind: SyntaxKind) -> bool {2578		NumberKind::can_cast(kind)2579	}2580	fn cast(syntax: SyntaxToken) -> Option<Self> {2581		let kind = NumberKind::cast(syntax.kind())?;2582		Some(Number { syntax, kind })2583	}2584	fn syntax(&self) -> &SyntaxToken {2585		&self.syntax2586	}2587}2588impl NumberKind {2589	fn can_cast(kind: SyntaxKind) -> bool {2590		match kind {2591			FLOAT2592			| ERROR_FLOAT_JUNK_AFTER_POINT2593			| ERROR_FLOAT_JUNK_AFTER_EXPONENT2594			| ERROR_FLOAT_JUNK_AFTER_EXPONENT_SIGN => true,2595			_ => false,2596		}2597	}2598	pub fn cast(kind: SyntaxKind) -> Option<Self> {2599		let res = match kind {2600			FLOAT => Self::Float,2601			ERROR_FLOAT_JUNK_AFTER_POINT => Self::ErrorFloatJunkAfterPoint,2602			ERROR_FLOAT_JUNK_AFTER_EXPONENT => Self::ErrorFloatJunkAfterExponent,2603			ERROR_FLOAT_JUNK_AFTER_EXPONENT_SIGN => Self::ErrorFloatJunkAfterExponentSign,2604			_ => return None,2605		};2606		Some(res)2607	}2608}2609impl Number {2610	pub fn kind(&self) -> NumberKind {2611		self.kind2612	}2613}2614impl std::fmt::Display for Number {2615	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2616		std::fmt::Display::fmt(self.syntax(), f)2617	}2618}2619impl AstToken for ImportKind {2620	fn can_cast(kind: SyntaxKind) -> bool {2621		ImportKindKind::can_cast(kind)2622	}2623	fn cast(syntax: SyntaxToken) -> Option<Self> {2624		let kind = ImportKindKind::cast(syntax.kind())?;2625		Some(ImportKind { syntax, kind })2626	}2627	fn syntax(&self) -> &SyntaxToken {2628		&self.syntax2629	}2630}2631impl ImportKindKind {2632	fn can_cast(kind: SyntaxKind) -> bool {2633		match kind {2634			IMPORTSTR_KW | IMPORTBIN_KW | IMPORT_KW => true,2635			_ => false,2636		}2637	}2638	pub fn cast(kind: SyntaxKind) -> Option<Self> {2639		let res = match kind {2640			IMPORTSTR_KW => Self::ImportstrKw,2641			IMPORTBIN_KW => Self::ImportbinKw,2642			IMPORT_KW => Self::ImportKw,2643			_ => return None,2644		};2645		Some(res)2646	}2647}2648impl ImportKind {2649	pub fn kind(&self) -> ImportKindKind {2650		self.kind2651	}2652}2653impl std::fmt::Display for ImportKind {2654	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2655		std::fmt::Display::fmt(self.syntax(), f)2656	}2657}2658impl AstToken for Trivia {2659	fn can_cast(kind: SyntaxKind) -> bool {2660		TriviaKind::can_cast(kind)2661	}2662	fn cast(syntax: SyntaxToken) -> Option<Self> {2663		let kind = TriviaKind::cast(syntax.kind())?;2664		Some(Trivia { syntax, kind })2665	}2666	fn syntax(&self) -> &SyntaxToken {2667		&self.syntax2668	}2669}2670impl TriviaKind {2671	fn can_cast(kind: SyntaxKind) -> bool {2672		match kind {2673			WHITESPACE2674			| MULTI_LINE_COMMENT2675			| ERROR_COMMENT_TOO_SHORT2676			| ERROR_COMMENT_UNTERMINATED2677			| SINGLE_LINE_HASH_COMMENT2678			| SINGLE_LINE_SLASH_COMMENT => true,2679			_ => false,2680		}2681	}2682	pub fn cast(kind: SyntaxKind) -> Option<Self> {2683		let res = match kind {2684			WHITESPACE => Self::Whitespace,2685			MULTI_LINE_COMMENT => Self::MultiLineComment,2686			ERROR_COMMENT_TOO_SHORT => Self::ErrorCommentTooShort,2687			ERROR_COMMENT_UNTERMINATED => Self::ErrorCommentUnterminated,2688			SINGLE_LINE_HASH_COMMENT => Self::SingleLineHashComment,2689			SINGLE_LINE_SLASH_COMMENT => Self::SingleLineSlashComment,2690			_ => return None,2691		};2692		Some(res)2693	}2694}2695impl Trivia {2696	pub fn kind(&self) -> TriviaKind {2697		self.kind2698	}2699}2700impl std::fmt::Display for Trivia {2701	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2702		std::fmt::Display::fmt(self.syntax(), f)2703	}2704}2705impl AstToken for CustomError {2706	fn can_cast(kind: SyntaxKind) -> bool {2707		CustomErrorKind::can_cast(kind)2708	}2709	fn cast(syntax: SyntaxToken) -> Option<Self> {2710		let kind = CustomErrorKind::cast(syntax.kind())?;2711		Some(CustomError { syntax, kind })2712	}2713	fn syntax(&self) -> &SyntaxToken {2714		&self.syntax2715	}2716}2717impl CustomErrorKind {2718	fn can_cast(kind: SyntaxKind) -> bool {2719		match kind {2720			ERROR_MISSING_TOKEN | ERROR_UNEXPECTED_TOKEN | ERROR_CUSTOM => true,2721			_ => false,2722		}2723	}2724	pub fn cast(kind: SyntaxKind) -> Option<Self> {2725		let res = match kind {2726			ERROR_MISSING_TOKEN => Self::ErrorMissingToken,2727			ERROR_UNEXPECTED_TOKEN => Self::ErrorUnexpectedToken,2728			ERROR_CUSTOM => Self::ErrorCustom,2729			_ => return None,2730		};2731		Some(res)2732	}2733}2734impl CustomError {2735	pub fn kind(&self) -> CustomErrorKind {2736		self.kind2737	}2738}2739impl std::fmt::Display for CustomError {2740	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2741		std::fmt::Display::fmt(self.syntax(), f)2742	}2743}2744impl std::fmt::Display for Suffix {2745	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2746		std::fmt::Display::fmt(self.syntax(), f)2747	}2748}2749impl std::fmt::Display for Bind {2750	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2751		std::fmt::Display::fmt(self.syntax(), f)2752	}2753}2754impl std::fmt::Display for Stmt {2755	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2756		std::fmt::Display::fmt(self.syntax(), f)2757	}2758}2759impl std::fmt::Display for ObjBody {2760	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2761		std::fmt::Display::fmt(self.syntax(), f)2762	}2763}2764impl std::fmt::Display for CompSpec {2765	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2766		std::fmt::Display::fmt(self.syntax(), f)2767	}2768}2769impl std::fmt::Display for ExprBase {2770	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2771		std::fmt::Display::fmt(self.syntax(), f)2772	}2773}2774impl std::fmt::Display for MemberComp {2775	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2776		std::fmt::Display::fmt(self.syntax(), f)2777	}2778}2779impl std::fmt::Display for Member {2780	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2781		std::fmt::Display::fmt(self.syntax(), f)2782	}2783}2784impl std::fmt::Display for FieldName {2785	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2786		std::fmt::Display::fmt(self.syntax(), f)2787	}2788}2789impl std::fmt::Display for Destruct {2790	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2791		std::fmt::Display::fmt(self.syntax(), f)2792	}2793}2794impl std::fmt::Display for DestructArrayPart {2795	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2796		std::fmt::Display::fmt(self.syntax(), f)2797	}2798}2799impl std::fmt::Display for SourceFile {2800	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2801		std::fmt::Display::fmt(self.syntax(), f)2802	}2803}2804impl std::fmt::Display for Expr {2805	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2806		std::fmt::Display::fmt(self.syntax(), f)2807	}2808}2809impl std::fmt::Display for SuffixIndex {2810	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2811		std::fmt::Display::fmt(self.syntax(), f)2812	}2813}2814impl std::fmt::Display for Name {2815	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2816		std::fmt::Display::fmt(self.syntax(), f)2817	}2818}2819impl std::fmt::Display for SuffixIndexExpr {2820	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2821		std::fmt::Display::fmt(self.syntax(), f)2822	}2823}2824impl std::fmt::Display for SuffixSlice {2825	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2826		std::fmt::Display::fmt(self.syntax(), f)2827	}2828}2829impl std::fmt::Display for SliceDesc {2830	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2831		std::fmt::Display::fmt(self.syntax(), f)2832	}2833}2834impl std::fmt::Display for SuffixApply {2835	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2836		std::fmt::Display::fmt(self.syntax(), f)2837	}2838}2839impl std::fmt::Display for ArgsDesc {2840	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2841		std::fmt::Display::fmt(self.syntax(), f)2842	}2843}2844impl std::fmt::Display for StmtLocal {2845	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2846		std::fmt::Display::fmt(self.syntax(), f)2847	}2848}2849impl std::fmt::Display for StmtAssert {2850	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2851		std::fmt::Display::fmt(self.syntax(), f)2852	}2853}2854impl std::fmt::Display for Assertion {2855	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2856		std::fmt::Display::fmt(self.syntax(), f)2857	}2858}2859impl std::fmt::Display for ExprBinary {2860	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2861		std::fmt::Display::fmt(self.syntax(), f)2862	}2863}2864impl std::fmt::Display for ExprUnary {2865	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2866		std::fmt::Display::fmt(self.syntax(), f)2867	}2868}2869impl std::fmt::Display for ExprObjExtend {2870	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2871		std::fmt::Display::fmt(self.syntax(), f)2872	}2873}2874impl std::fmt::Display for ExprParened {2875	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2876		std::fmt::Display::fmt(self.syntax(), f)2877	}2878}2879impl std::fmt::Display for ExprLiteral {2880	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2881		std::fmt::Display::fmt(self.syntax(), f)2882	}2883}2884impl std::fmt::Display for ExprString {2885	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2886		std::fmt::Display::fmt(self.syntax(), f)2887	}2888}2889impl std::fmt::Display for ExprNumber {2890	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2891		std::fmt::Display::fmt(self.syntax(), f)2892	}2893}2894impl std::fmt::Display for ExprArray {2895	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2896		std::fmt::Display::fmt(self.syntax(), f)2897	}2898}2899impl std::fmt::Display for ExprObject {2900	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2901		std::fmt::Display::fmt(self.syntax(), f)2902	}2903}2904impl std::fmt::Display for ExprArrayComp {2905	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2906		std::fmt::Display::fmt(self.syntax(), f)2907	}2908}2909impl std::fmt::Display for ExprImport {2910	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2911		std::fmt::Display::fmt(self.syntax(), f)2912	}2913}2914impl std::fmt::Display for ExprVar {2915	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2916		std::fmt::Display::fmt(self.syntax(), f)2917	}2918}2919impl std::fmt::Display for ExprIfThenElse {2920	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2921		std::fmt::Display::fmt(self.syntax(), f)2922	}2923}2924impl std::fmt::Display for TrueExpr {2925	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2926		std::fmt::Display::fmt(self.syntax(), f)2927	}2928}2929impl std::fmt::Display for FalseExpr {2930	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2931		std::fmt::Display::fmt(self.syntax(), f)2932	}2933}2934impl std::fmt::Display for ExprFunction {2935	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2936		std::fmt::Display::fmt(self.syntax(), f)2937	}2938}2939impl std::fmt::Display for ParamsDesc {2940	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2941		std::fmt::Display::fmt(self.syntax(), f)2942	}2943}2944impl std::fmt::Display for ExprError {2945	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2946		std::fmt::Display::fmt(self.syntax(), f)2947	}2948}2949impl std::fmt::Display for SliceDescEnd {2950	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2951		std::fmt::Display::fmt(self.syntax(), f)2952	}2953}2954impl std::fmt::Display for SliceDescStep {2955	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2956		std::fmt::Display::fmt(self.syntax(), f)2957	}2958}2959impl std::fmt::Display for Arg {2960	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2961		std::fmt::Display::fmt(self.syntax(), f)2962	}2963}2964impl std::fmt::Display for ObjBodyComp {2965	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2966		std::fmt::Display::fmt(self.syntax(), f)2967	}2968}2969impl std::fmt::Display for ObjBodyMemberList {2970	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2971		std::fmt::Display::fmt(self.syntax(), f)2972	}2973}2974impl std::fmt::Display for MemberBindStmt {2975	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2976		std::fmt::Display::fmt(self.syntax(), f)2977	}2978}2979impl std::fmt::Display for ObjLocal {2980	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2981		std::fmt::Display::fmt(self.syntax(), f)2982	}2983}2984impl std::fmt::Display for MemberAssertStmt {2985	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2986		std::fmt::Display::fmt(self.syntax(), f)2987	}2988}2989impl std::fmt::Display for MemberFieldNormal {2990	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2991		std::fmt::Display::fmt(self.syntax(), f)2992	}2993}2994impl std::fmt::Display for Visibility {2995	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2996		std::fmt::Display::fmt(self.syntax(), f)2997	}2998}2999impl std::fmt::Display for MemberFieldMethod {3000	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3001		std::fmt::Display::fmt(self.syntax(), f)3002	}3003}3004impl std::fmt::Display for FieldNameFixed {3005	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3006		std::fmt::Display::fmt(self.syntax(), f)3007	}3008}3009impl std::fmt::Display for FieldNameDynamic {3010	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3011		std::fmt::Display::fmt(self.syntax(), f)3012	}3013}3014impl std::fmt::Display for ForSpec {3015	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3016		std::fmt::Display::fmt(self.syntax(), f)3017	}3018}3019impl std::fmt::Display for IfSpec {3020	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3021		std::fmt::Display::fmt(self.syntax(), f)3022	}3023}3024impl std::fmt::Display for BindDestruct {3025	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3026		std::fmt::Display::fmt(self.syntax(), f)3027	}3028}3029impl std::fmt::Display for BindFunction {3030	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3031		std::fmt::Display::fmt(self.syntax(), f)3032	}3033}3034impl std::fmt::Display for Param {3035	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3036		std::fmt::Display::fmt(self.syntax(), f)3037	}3038}3039impl std::fmt::Display for DestructFull {3040	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3041		std::fmt::Display::fmt(self.syntax(), f)3042	}3043}3044impl std::fmt::Display for DestructSkip {3045	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3046		std::fmt::Display::fmt(self.syntax(), f)3047	}3048}3049impl std::fmt::Display for DestructArray {3050	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3051		std::fmt::Display::fmt(self.syntax(), f)3052	}3053}3054impl std::fmt::Display for DestructObject {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 DestructObjectField {3060	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3061		std::fmt::Display::fmt(self.syntax(), f)3062	}3063}3064impl std::fmt::Display for DestructRest {3065	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3066		std::fmt::Display::fmt(self.syntax(), f)3067	}3068}3069impl std::fmt::Display for DestructArrayElement {3070	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3071		std::fmt::Display::fmt(self.syntax(), f)3072	}3073}