git.delta.rocks / jrsonnet / refs/heads / master

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	SyntaxKind::{self, *},7	SyntaxNode, SyntaxToken, T,8	ast::{AstChildren, AstNode, AstToken, support},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 ForObjSpec {654	pub(crate) syntax: SyntaxNode,655}656impl ForObjSpec {657	pub fn for_kw_token(&self) -> Option<SyntaxToken> {658		support::token(&self.syntax, T![for])659	}660	pub fn l_brack_token(&self) -> Option<SyntaxToken> {661		support::token(&self.syntax, T!['['])662	}663	pub fn key(&self) -> Option<Name> {664		support::children(&self.syntax).next()665	}666	pub fn r_brack_token(&self) -> Option<SyntaxToken> {667		support::token(&self.syntax, T![']'])668	}669	pub fn visibility(&self) -> Option<Visibility> {670		support::children(&self.syntax).next()671	}672	pub fn value(&self) -> Option<Destruct> {673		support::children(&self.syntax).next()674	}675	pub fn in_kw_token(&self) -> Option<SyntaxToken> {676		support::token(&self.syntax, T![in])677	}678	pub fn expr(&self) -> Option<Expr> {679		support::children(&self.syntax).next()680	}681}682683#[derive(Debug, Clone, PartialEq, Eq, Hash)]684pub struct IfSpec {685	pub(crate) syntax: SyntaxNode,686}687impl IfSpec {688	pub fn if_kw_token(&self) -> Option<SyntaxToken> {689		support::token(&self.syntax, T![if])690	}691	pub fn expr(&self) -> Option<Expr> {692		support::children(&self.syntax).next()693	}694}695696#[derive(Debug, Clone, PartialEq, Eq, Hash)]697pub struct BindDestruct {698	pub(crate) syntax: SyntaxNode,699}700impl BindDestruct {701	pub fn into(&self) -> Option<Destruct> {702		support::children(&self.syntax).next()703	}704	pub fn assign_token(&self) -> Option<SyntaxToken> {705		support::token(&self.syntax, T![=])706	}707	pub fn value(&self) -> Option<Expr> {708		support::children(&self.syntax).next()709	}710}711712#[derive(Debug, Clone, PartialEq, Eq, Hash)]713pub struct BindFunction {714	pub(crate) syntax: SyntaxNode,715}716impl BindFunction {717	pub fn name(&self) -> Option<Name> {718		support::children(&self.syntax).next()719	}720	pub fn params(&self) -> Option<ParamsDesc> {721		support::children(&self.syntax).next()722	}723	pub fn assign_token(&self) -> Option<SyntaxToken> {724		support::token(&self.syntax, T![=])725	}726	pub fn value(&self) -> Option<Expr> {727		support::children(&self.syntax).next()728	}729}730731#[derive(Debug, Clone, PartialEq, Eq, Hash)]732pub struct Param {733	pub(crate) syntax: SyntaxNode,734}735impl Param {736	pub fn destruct(&self) -> Option<Destruct> {737		support::children(&self.syntax).next()738	}739	pub fn assign_token(&self) -> Option<SyntaxToken> {740		support::token(&self.syntax, T![=])741	}742	pub fn expr(&self) -> Option<Expr> {743		support::children(&self.syntax).next()744	}745}746747#[derive(Debug, Clone, PartialEq, Eq, Hash)]748pub struct DestructFull {749	pub(crate) syntax: SyntaxNode,750}751impl DestructFull {752	pub fn name(&self) -> Option<Name> {753		support::children(&self.syntax).next()754	}755}756757#[derive(Debug, Clone, PartialEq, Eq, Hash)]758pub struct DestructSkip {759	pub(crate) syntax: SyntaxNode,760}761impl DestructSkip {762	pub fn question_mark_token(&self) -> Option<SyntaxToken> {763		support::token(&self.syntax, T![?])764	}765}766767#[derive(Debug, Clone, PartialEq, Eq, Hash)]768pub struct DestructArray {769	pub(crate) syntax: SyntaxNode,770}771impl DestructArray {772	pub fn l_brack_token(&self) -> Option<SyntaxToken> {773		support::token(&self.syntax, T!['['])774	}775	pub fn destruct_array_parts(&self) -> AstChildren<DestructArrayPart> {776		support::children(&self.syntax)777	}778	pub fn r_brack_token(&self) -> Option<SyntaxToken> {779		support::token(&self.syntax, T![']'])780	}781}782783#[derive(Debug, Clone, PartialEq, Eq, Hash)]784pub struct DestructObject {785	pub(crate) syntax: SyntaxNode,786}787impl DestructObject {788	pub fn l_brace_token(&self) -> Option<SyntaxToken> {789		support::token(&self.syntax, T!['{'])790	}791	pub fn destruct_object_fields(&self) -> AstChildren<DestructObjectField> {792		support::children(&self.syntax)793	}794	pub fn destruct_rest(&self) -> Option<DestructRest> {795		support::children(&self.syntax).next()796	}797	pub fn comma_token(&self) -> Option<SyntaxToken> {798		support::token(&self.syntax, T![,])799	}800	pub fn r_brace_token(&self) -> Option<SyntaxToken> {801		support::token(&self.syntax, T!['}'])802	}803}804805#[derive(Debug, Clone, PartialEq, Eq, Hash)]806pub struct DestructObjectField {807	pub(crate) syntax: SyntaxNode,808}809impl DestructObjectField {810	pub fn field(&self) -> Option<Name> {811		support::children(&self.syntax).next()812	}813	pub fn colon_token(&self) -> Option<SyntaxToken> {814		support::token(&self.syntax, T![:])815	}816	pub fn destruct(&self) -> Option<Destruct> {817		support::children(&self.syntax).next()818	}819	pub fn assign_token(&self) -> Option<SyntaxToken> {820		support::token(&self.syntax, T![=])821	}822	pub fn expr(&self) -> Option<Expr> {823		support::children(&self.syntax).next()824	}825}826827#[derive(Debug, Clone, PartialEq, Eq, Hash)]828pub struct DestructRest {829	pub(crate) syntax: SyntaxNode,830}831impl DestructRest {832	pub fn dotdotdot_token(&self) -> Option<SyntaxToken> {833		support::token(&self.syntax, T![...])834	}835	pub fn into(&self) -> Option<Name> {836		support::children(&self.syntax).next()837	}838}839840#[derive(Debug, Clone, PartialEq, Eq, Hash)]841pub struct DestructArrayElement {842	pub(crate) syntax: SyntaxNode,843}844impl DestructArrayElement {845	pub fn destruct(&self) -> Option<Destruct> {846		support::children(&self.syntax).next()847	}848}849850#[derive(Debug, Clone, PartialEq, Eq, Hash)]851pub enum Suffix {852	SuffixIndex(SuffixIndex),853	SuffixIndexExpr(SuffixIndexExpr),854	SuffixSlice(SuffixSlice),855	SuffixApply(SuffixApply),856}857858#[derive(Debug, Clone, PartialEq, Eq, Hash)]859pub enum Bind {860	BindDestruct(BindDestruct),861	BindFunction(BindFunction),862}863864#[derive(Debug, Clone, PartialEq, Eq, Hash)]865pub enum Stmt {866	StmtLocal(StmtLocal),867	StmtAssert(StmtAssert),868}869870#[derive(Debug, Clone, PartialEq, Eq, Hash)]871pub enum ObjBody {872	ObjBodyComp(ObjBodyComp),873	ObjBodyMemberList(ObjBodyMemberList),874}875876#[derive(Debug, Clone, PartialEq, Eq, Hash)]877pub enum CompSpec {878	ForSpec(ForSpec),879	ForObjSpec(ForObjSpec),880	IfSpec(IfSpec),881}882883#[derive(Debug, Clone, PartialEq, Eq, Hash)]884pub enum ExprBase {885	ExprBinary(ExprBinary),886	ExprUnary(ExprUnary),887	ExprObjExtend(ExprObjExtend),888	ExprParened(ExprParened),889	ExprString(ExprString),890	ExprNumber(ExprNumber),891	ExprLiteral(ExprLiteral),892	ExprArray(ExprArray),893	ExprObject(ExprObject),894	ExprArrayComp(ExprArrayComp),895	ExprImport(ExprImport),896	ExprVar(ExprVar),897	ExprIfThenElse(ExprIfThenElse),898	ExprFunction(ExprFunction),899	ExprError(ExprError),900}901902#[derive(Debug, Clone, PartialEq, Eq, Hash)]903pub enum MemberComp {904	MemberBindStmt(MemberBindStmt),905	MemberFieldNormal(MemberFieldNormal),906	MemberFieldMethod(MemberFieldMethod),907}908909#[derive(Debug, Clone, PartialEq, Eq, Hash)]910pub enum Member {911	MemberBindStmt(MemberBindStmt),912	MemberAssertStmt(MemberAssertStmt),913	MemberFieldNormal(MemberFieldNormal),914	MemberFieldMethod(MemberFieldMethod),915}916917#[derive(Debug, Clone, PartialEq, Eq, Hash)]918pub enum FieldName {919	FieldNameFixed(FieldNameFixed),920	FieldNameDynamic(FieldNameDynamic),921}922923#[derive(Debug, Clone, PartialEq, Eq, Hash)]924pub enum Destruct {925	DestructFull(DestructFull),926	DestructSkip(DestructSkip),927	DestructArray(DestructArray),928	DestructObject(DestructObject),929}930931#[derive(Debug, Clone, PartialEq, Eq, Hash)]932pub enum DestructArrayPart {933	DestructArrayElement(DestructArrayElement),934	DestructRest(DestructRest),935}936937#[derive(Debug, Clone, PartialEq, Eq, Hash)]938pub struct BinaryOperator {939	syntax: SyntaxToken,940	kind: BinaryOperatorKind,941}942943#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]944pub enum BinaryOperatorKind {945	Or,946	NullCoaelse,947	And,948	BitOr,949	BitXor,950	BitAnd,951	Eq,952	Ne,953	Lt,954	Gt,955	Le,956	Ge,957	InKw,958	Lhs,959	Rhs,960	Plus,961	Minus,962	Mul,963	Div,964	Modulo,965	MetaObjectApply,966	ErrorNoOperator,967}968969#[derive(Debug, Clone, PartialEq, Eq, Hash)]970pub struct UnaryOperator {971	syntax: SyntaxToken,972	kind: UnaryOperatorKind,973}974975#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]976pub enum UnaryOperatorKind {977	Minus,978	Not,979	BitNot,980	Plus,981}982983#[derive(Debug, Clone, PartialEq, Eq, Hash)]984pub struct Literal {985	syntax: SyntaxToken,986	kind: LiteralKind,987}988989#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]990pub enum LiteralKind {991	NullKw,992	TrueKw,993	FalseKw,994	SelfKw,995	Dollar,996	SuperKw,997}998999#[derive(Debug, Clone, PartialEq, Eq, Hash)]1000pub struct Text {1001	syntax: SyntaxToken,1002	kind: TextKind,1003}10041005#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]1006pub enum TextKind {1007	StringDouble,1008	ErrorStringDoubleUnterminated,1009	StringSingle,1010	ErrorStringSingleUnterminated,1011	StringDoubleVerbatim,1012	ErrorStringDoubleVerbatimUnterminated,1013	StringSingleVerbatim,1014	ErrorStringSingleVerbatimUnterminated,1015	ErrorStringVerbatimMissingQuotes,1016	StringBlock,1017	ErrorStringBlockUnexpectedEnd,1018	ErrorStringBlockMissingNewLine,1019	ErrorStringBlockMissingTermination,1020	ErrorStringBlockMissingIndent,1021}10221023#[derive(Debug, Clone, PartialEq, Eq, Hash)]1024pub struct Number {1025	syntax: SyntaxToken,1026	kind: NumberKind,1027}10281029#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]1030pub enum NumberKind {1031	Float,1032	ErrorFloatJunkAfterPoint,1033	ErrorFloatJunkAfterExponent,1034	ErrorFloatJunkAfterExponentSign,1035}10361037#[derive(Debug, Clone, PartialEq, Eq, Hash)]1038pub struct ImportKind {1039	syntax: SyntaxToken,1040	kind: ImportKindKind,1041}10421043#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]1044pub enum ImportKindKind {1045	ImportstrKw,1046	ImportbinKw,1047	ImportKw,1048}10491050#[derive(Debug, Clone, PartialEq, Eq, Hash)]1051pub struct Trivia {1052	syntax: SyntaxToken,1053	kind: TriviaKind,1054}10551056#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]1057pub enum TriviaKind {1058	Whitespace,1059	MultiLineComment,1060	ErrorCommentTooShort,1061	ErrorCommentUnterminated,1062	SingleLineHashComment,1063	SingleLineSlashComment,1064}10651066#[derive(Debug, Clone, PartialEq, Eq, Hash)]1067pub struct CustomError {1068	syntax: SyntaxToken,1069	kind: CustomErrorKind,1070}10711072#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]1073pub enum CustomErrorKind {1074	ErrorMissingToken,1075	ErrorUnexpectedToken,1076	ErrorCustom,1077}1078impl AstNode for SourceFile {1079	fn can_cast(kind: SyntaxKind) -> bool {1080		kind == SOURCE_FILE1081	}1082	fn cast(syntax: SyntaxNode) -> Option<Self> {1083		if Self::can_cast(syntax.kind()) {1084			Some(Self { syntax })1085		} else {1086			None1087		}1088	}1089	fn syntax(&self) -> &SyntaxNode {1090		&self.syntax1091	}1092}1093impl AstNode for Expr {1094	fn can_cast(kind: SyntaxKind) -> bool {1095		kind == EXPR1096	}1097	fn cast(syntax: SyntaxNode) -> Option<Self> {1098		if Self::can_cast(syntax.kind()) {1099			Some(Self { syntax })1100		} else {1101			None1102		}1103	}1104	fn syntax(&self) -> &SyntaxNode {1105		&self.syntax1106	}1107}1108impl AstNode for SuffixIndex {1109	fn can_cast(kind: SyntaxKind) -> bool {1110		kind == SUFFIX_INDEX1111	}1112	fn cast(syntax: SyntaxNode) -> Option<Self> {1113		if Self::can_cast(syntax.kind()) {1114			Some(Self { syntax })1115		} else {1116			None1117		}1118	}1119	fn syntax(&self) -> &SyntaxNode {1120		&self.syntax1121	}1122}1123impl AstNode for Name {1124	fn can_cast(kind: SyntaxKind) -> bool {1125		kind == NAME1126	}1127	fn cast(syntax: SyntaxNode) -> Option<Self> {1128		if Self::can_cast(syntax.kind()) {1129			Some(Self { syntax })1130		} else {1131			None1132		}1133	}1134	fn syntax(&self) -> &SyntaxNode {1135		&self.syntax1136	}1137}1138impl AstNode for SuffixIndexExpr {1139	fn can_cast(kind: SyntaxKind) -> bool {1140		kind == SUFFIX_INDEX_EXPR1141	}1142	fn cast(syntax: SyntaxNode) -> Option<Self> {1143		if Self::can_cast(syntax.kind()) {1144			Some(Self { syntax })1145		} else {1146			None1147		}1148	}1149	fn syntax(&self) -> &SyntaxNode {1150		&self.syntax1151	}1152}1153impl AstNode for SuffixSlice {1154	fn can_cast(kind: SyntaxKind) -> bool {1155		kind == SUFFIX_SLICE1156	}1157	fn cast(syntax: SyntaxNode) -> Option<Self> {1158		if Self::can_cast(syntax.kind()) {1159			Some(Self { syntax })1160		} else {1161			None1162		}1163	}1164	fn syntax(&self) -> &SyntaxNode {1165		&self.syntax1166	}1167}1168impl AstNode for SliceDesc {1169	fn can_cast(kind: SyntaxKind) -> bool {1170		kind == SLICE_DESC1171	}1172	fn cast(syntax: SyntaxNode) -> Option<Self> {1173		if Self::can_cast(syntax.kind()) {1174			Some(Self { syntax })1175		} else {1176			None1177		}1178	}1179	fn syntax(&self) -> &SyntaxNode {1180		&self.syntax1181	}1182}1183impl AstNode for SuffixApply {1184	fn can_cast(kind: SyntaxKind) -> bool {1185		kind == SUFFIX_APPLY1186	}1187	fn cast(syntax: SyntaxNode) -> Option<Self> {1188		if Self::can_cast(syntax.kind()) {1189			Some(Self { syntax })1190		} else {1191			None1192		}1193	}1194	fn syntax(&self) -> &SyntaxNode {1195		&self.syntax1196	}1197}1198impl AstNode for ArgsDesc {1199	fn can_cast(kind: SyntaxKind) -> bool {1200		kind == ARGS_DESC1201	}1202	fn cast(syntax: SyntaxNode) -> Option<Self> {1203		if Self::can_cast(syntax.kind()) {1204			Some(Self { syntax })1205		} else {1206			None1207		}1208	}1209	fn syntax(&self) -> &SyntaxNode {1210		&self.syntax1211	}1212}1213impl AstNode for StmtLocal {1214	fn can_cast(kind: SyntaxKind) -> bool {1215		kind == STMT_LOCAL1216	}1217	fn cast(syntax: SyntaxNode) -> Option<Self> {1218		if Self::can_cast(syntax.kind()) {1219			Some(Self { syntax })1220		} else {1221			None1222		}1223	}1224	fn syntax(&self) -> &SyntaxNode {1225		&self.syntax1226	}1227}1228impl AstNode for StmtAssert {1229	fn can_cast(kind: SyntaxKind) -> bool {1230		kind == STMT_ASSERT1231	}1232	fn cast(syntax: SyntaxNode) -> Option<Self> {1233		if Self::can_cast(syntax.kind()) {1234			Some(Self { syntax })1235		} else {1236			None1237		}1238	}1239	fn syntax(&self) -> &SyntaxNode {1240		&self.syntax1241	}1242}1243impl AstNode for Assertion {1244	fn can_cast(kind: SyntaxKind) -> bool {1245		kind == ASSERTION1246	}1247	fn cast(syntax: SyntaxNode) -> Option<Self> {1248		if Self::can_cast(syntax.kind()) {1249			Some(Self { syntax })1250		} else {1251			None1252		}1253	}1254	fn syntax(&self) -> &SyntaxNode {1255		&self.syntax1256	}1257}1258impl AstNode for ExprBinary {1259	fn can_cast(kind: SyntaxKind) -> bool {1260		kind == EXPR_BINARY1261	}1262	fn cast(syntax: SyntaxNode) -> Option<Self> {1263		if Self::can_cast(syntax.kind()) {1264			Some(Self { syntax })1265		} else {1266			None1267		}1268	}1269	fn syntax(&self) -> &SyntaxNode {1270		&self.syntax1271	}1272}1273impl AstNode for ExprUnary {1274	fn can_cast(kind: SyntaxKind) -> bool {1275		kind == EXPR_UNARY1276	}1277	fn cast(syntax: SyntaxNode) -> Option<Self> {1278		if Self::can_cast(syntax.kind()) {1279			Some(Self { syntax })1280		} else {1281			None1282		}1283	}1284	fn syntax(&self) -> &SyntaxNode {1285		&self.syntax1286	}1287}1288impl AstNode for ExprObjExtend {1289	fn can_cast(kind: SyntaxKind) -> bool {1290		kind == EXPR_OBJ_EXTEND1291	}1292	fn cast(syntax: SyntaxNode) -> Option<Self> {1293		if Self::can_cast(syntax.kind()) {1294			Some(Self { syntax })1295		} else {1296			None1297		}1298	}1299	fn syntax(&self) -> &SyntaxNode {1300		&self.syntax1301	}1302}1303impl AstNode for ExprParened {1304	fn can_cast(kind: SyntaxKind) -> bool {1305		kind == EXPR_PARENED1306	}1307	fn cast(syntax: SyntaxNode) -> Option<Self> {1308		if Self::can_cast(syntax.kind()) {1309			Some(Self { syntax })1310		} else {1311			None1312		}1313	}1314	fn syntax(&self) -> &SyntaxNode {1315		&self.syntax1316	}1317}1318impl AstNode for ExprLiteral {1319	fn can_cast(kind: SyntaxKind) -> bool {1320		kind == EXPR_LITERAL1321	}1322	fn cast(syntax: SyntaxNode) -> Option<Self> {1323		if Self::can_cast(syntax.kind()) {1324			Some(Self { syntax })1325		} else {1326			None1327		}1328	}1329	fn syntax(&self) -> &SyntaxNode {1330		&self.syntax1331	}1332}1333impl AstNode for ExprString {1334	fn can_cast(kind: SyntaxKind) -> bool {1335		kind == EXPR_STRING1336	}1337	fn cast(syntax: SyntaxNode) -> Option<Self> {1338		if Self::can_cast(syntax.kind()) {1339			Some(Self { syntax })1340		} else {1341			None1342		}1343	}1344	fn syntax(&self) -> &SyntaxNode {1345		&self.syntax1346	}1347}1348impl AstNode for ExprNumber {1349	fn can_cast(kind: SyntaxKind) -> bool {1350		kind == EXPR_NUMBER1351	}1352	fn cast(syntax: SyntaxNode) -> Option<Self> {1353		if Self::can_cast(syntax.kind()) {1354			Some(Self { syntax })1355		} else {1356			None1357		}1358	}1359	fn syntax(&self) -> &SyntaxNode {1360		&self.syntax1361	}1362}1363impl AstNode for ExprArray {1364	fn can_cast(kind: SyntaxKind) -> bool {1365		kind == EXPR_ARRAY1366	}1367	fn cast(syntax: SyntaxNode) -> Option<Self> {1368		if Self::can_cast(syntax.kind()) {1369			Some(Self { syntax })1370		} else {1371			None1372		}1373	}1374	fn syntax(&self) -> &SyntaxNode {1375		&self.syntax1376	}1377}1378impl AstNode for ExprObject {1379	fn can_cast(kind: SyntaxKind) -> bool {1380		kind == EXPR_OBJECT1381	}1382	fn cast(syntax: SyntaxNode) -> Option<Self> {1383		if Self::can_cast(syntax.kind()) {1384			Some(Self { syntax })1385		} else {1386			None1387		}1388	}1389	fn syntax(&self) -> &SyntaxNode {1390		&self.syntax1391	}1392}1393impl AstNode for ExprArrayComp {1394	fn can_cast(kind: SyntaxKind) -> bool {1395		kind == EXPR_ARRAY_COMP1396	}1397	fn cast(syntax: SyntaxNode) -> Option<Self> {1398		if Self::can_cast(syntax.kind()) {1399			Some(Self { syntax })1400		} else {1401			None1402		}1403	}1404	fn syntax(&self) -> &SyntaxNode {1405		&self.syntax1406	}1407}1408impl AstNode for ExprImport {1409	fn can_cast(kind: SyntaxKind) -> bool {1410		kind == EXPR_IMPORT1411	}1412	fn cast(syntax: SyntaxNode) -> Option<Self> {1413		if Self::can_cast(syntax.kind()) {1414			Some(Self { syntax })1415		} else {1416			None1417		}1418	}1419	fn syntax(&self) -> &SyntaxNode {1420		&self.syntax1421	}1422}1423impl AstNode for ExprVar {1424	fn can_cast(kind: SyntaxKind) -> bool {1425		kind == EXPR_VAR1426	}1427	fn cast(syntax: SyntaxNode) -> Option<Self> {1428		if Self::can_cast(syntax.kind()) {1429			Some(Self { syntax })1430		} else {1431			None1432		}1433	}1434	fn syntax(&self) -> &SyntaxNode {1435		&self.syntax1436	}1437}1438impl AstNode for ExprIfThenElse {1439	fn can_cast(kind: SyntaxKind) -> bool {1440		kind == EXPR_IF_THEN_ELSE1441	}1442	fn cast(syntax: SyntaxNode) -> Option<Self> {1443		if Self::can_cast(syntax.kind()) {1444			Some(Self { syntax })1445		} else {1446			None1447		}1448	}1449	fn syntax(&self) -> &SyntaxNode {1450		&self.syntax1451	}1452}1453impl AstNode for TrueExpr {1454	fn can_cast(kind: SyntaxKind) -> bool {1455		kind == TRUE_EXPR1456	}1457	fn cast(syntax: SyntaxNode) -> Option<Self> {1458		if Self::can_cast(syntax.kind()) {1459			Some(Self { syntax })1460		} else {1461			None1462		}1463	}1464	fn syntax(&self) -> &SyntaxNode {1465		&self.syntax1466	}1467}1468impl AstNode for FalseExpr {1469	fn can_cast(kind: SyntaxKind) -> bool {1470		kind == FALSE_EXPR1471	}1472	fn cast(syntax: SyntaxNode) -> Option<Self> {1473		if Self::can_cast(syntax.kind()) {1474			Some(Self { syntax })1475		} else {1476			None1477		}1478	}1479	fn syntax(&self) -> &SyntaxNode {1480		&self.syntax1481	}1482}1483impl AstNode for ExprFunction {1484	fn can_cast(kind: SyntaxKind) -> bool {1485		kind == EXPR_FUNCTION1486	}1487	fn cast(syntax: SyntaxNode) -> Option<Self> {1488		if Self::can_cast(syntax.kind()) {1489			Some(Self { syntax })1490		} else {1491			None1492		}1493	}1494	fn syntax(&self) -> &SyntaxNode {1495		&self.syntax1496	}1497}1498impl AstNode for ParamsDesc {1499	fn can_cast(kind: SyntaxKind) -> bool {1500		kind == PARAMS_DESC1501	}1502	fn cast(syntax: SyntaxNode) -> Option<Self> {1503		if Self::can_cast(syntax.kind()) {1504			Some(Self { syntax })1505		} else {1506			None1507		}1508	}1509	fn syntax(&self) -> &SyntaxNode {1510		&self.syntax1511	}1512}1513impl AstNode for ExprError {1514	fn can_cast(kind: SyntaxKind) -> bool {1515		kind == EXPR_ERROR1516	}1517	fn cast(syntax: SyntaxNode) -> Option<Self> {1518		if Self::can_cast(syntax.kind()) {1519			Some(Self { syntax })1520		} else {1521			None1522		}1523	}1524	fn syntax(&self) -> &SyntaxNode {1525		&self.syntax1526	}1527}1528impl AstNode for SliceDescEnd {1529	fn can_cast(kind: SyntaxKind) -> bool {1530		kind == SLICE_DESC_END1531	}1532	fn cast(syntax: SyntaxNode) -> Option<Self> {1533		if Self::can_cast(syntax.kind()) {1534			Some(Self { syntax })1535		} else {1536			None1537		}1538	}1539	fn syntax(&self) -> &SyntaxNode {1540		&self.syntax1541	}1542}1543impl AstNode for SliceDescStep {1544	fn can_cast(kind: SyntaxKind) -> bool {1545		kind == SLICE_DESC_STEP1546	}1547	fn cast(syntax: SyntaxNode) -> Option<Self> {1548		if Self::can_cast(syntax.kind()) {1549			Some(Self { syntax })1550		} else {1551			None1552		}1553	}1554	fn syntax(&self) -> &SyntaxNode {1555		&self.syntax1556	}1557}1558impl AstNode for Arg {1559	fn can_cast(kind: SyntaxKind) -> bool {1560		kind == ARG1561	}1562	fn cast(syntax: SyntaxNode) -> Option<Self> {1563		if Self::can_cast(syntax.kind()) {1564			Some(Self { syntax })1565		} else {1566			None1567		}1568	}1569	fn syntax(&self) -> &SyntaxNode {1570		&self.syntax1571	}1572}1573impl AstNode for ObjBodyComp {1574	fn can_cast(kind: SyntaxKind) -> bool {1575		kind == OBJ_BODY_COMP1576	}1577	fn cast(syntax: SyntaxNode) -> Option<Self> {1578		if Self::can_cast(syntax.kind()) {1579			Some(Self { syntax })1580		} else {1581			None1582		}1583	}1584	fn syntax(&self) -> &SyntaxNode {1585		&self.syntax1586	}1587}1588impl AstNode for ObjBodyMemberList {1589	fn can_cast(kind: SyntaxKind) -> bool {1590		kind == OBJ_BODY_MEMBER_LIST1591	}1592	fn cast(syntax: SyntaxNode) -> Option<Self> {1593		if Self::can_cast(syntax.kind()) {1594			Some(Self { syntax })1595		} else {1596			None1597		}1598	}1599	fn syntax(&self) -> &SyntaxNode {1600		&self.syntax1601	}1602}1603impl AstNode for MemberBindStmt {1604	fn can_cast(kind: SyntaxKind) -> bool {1605		kind == MEMBER_BIND_STMT1606	}1607	fn cast(syntax: SyntaxNode) -> Option<Self> {1608		if Self::can_cast(syntax.kind()) {1609			Some(Self { syntax })1610		} else {1611			None1612		}1613	}1614	fn syntax(&self) -> &SyntaxNode {1615		&self.syntax1616	}1617}1618impl AstNode for ObjLocal {1619	fn can_cast(kind: SyntaxKind) -> bool {1620		kind == OBJ_LOCAL1621	}1622	fn cast(syntax: SyntaxNode) -> Option<Self> {1623		if Self::can_cast(syntax.kind()) {1624			Some(Self { syntax })1625		} else {1626			None1627		}1628	}1629	fn syntax(&self) -> &SyntaxNode {1630		&self.syntax1631	}1632}1633impl AstNode for MemberAssertStmt {1634	fn can_cast(kind: SyntaxKind) -> bool {1635		kind == MEMBER_ASSERT_STMT1636	}1637	fn cast(syntax: SyntaxNode) -> Option<Self> {1638		if Self::can_cast(syntax.kind()) {1639			Some(Self { syntax })1640		} else {1641			None1642		}1643	}1644	fn syntax(&self) -> &SyntaxNode {1645		&self.syntax1646	}1647}1648impl AstNode for MemberFieldNormal {1649	fn can_cast(kind: SyntaxKind) -> bool {1650		kind == MEMBER_FIELD_NORMAL1651	}1652	fn cast(syntax: SyntaxNode) -> Option<Self> {1653		if Self::can_cast(syntax.kind()) {1654			Some(Self { syntax })1655		} else {1656			None1657		}1658	}1659	fn syntax(&self) -> &SyntaxNode {1660		&self.syntax1661	}1662}1663impl AstNode for Visibility {1664	fn can_cast(kind: SyntaxKind) -> bool {1665		kind == VISIBILITY1666	}1667	fn cast(syntax: SyntaxNode) -> Option<Self> {1668		if Self::can_cast(syntax.kind()) {1669			Some(Self { syntax })1670		} else {1671			None1672		}1673	}1674	fn syntax(&self) -> &SyntaxNode {1675		&self.syntax1676	}1677}1678impl AstNode for MemberFieldMethod {1679	fn can_cast(kind: SyntaxKind) -> bool {1680		kind == MEMBER_FIELD_METHOD1681	}1682	fn cast(syntax: SyntaxNode) -> Option<Self> {1683		if Self::can_cast(syntax.kind()) {1684			Some(Self { syntax })1685		} else {1686			None1687		}1688	}1689	fn syntax(&self) -> &SyntaxNode {1690		&self.syntax1691	}1692}1693impl AstNode for FieldNameFixed {1694	fn can_cast(kind: SyntaxKind) -> bool {1695		kind == FIELD_NAME_FIXED1696	}1697	fn cast(syntax: SyntaxNode) -> Option<Self> {1698		if Self::can_cast(syntax.kind()) {1699			Some(Self { syntax })1700		} else {1701			None1702		}1703	}1704	fn syntax(&self) -> &SyntaxNode {1705		&self.syntax1706	}1707}1708impl AstNode for FieldNameDynamic {1709	fn can_cast(kind: SyntaxKind) -> bool {1710		kind == FIELD_NAME_DYNAMIC1711	}1712	fn cast(syntax: SyntaxNode) -> Option<Self> {1713		if Self::can_cast(syntax.kind()) {1714			Some(Self { syntax })1715		} else {1716			None1717		}1718	}1719	fn syntax(&self) -> &SyntaxNode {1720		&self.syntax1721	}1722}1723impl AstNode for ForSpec {1724	fn can_cast(kind: SyntaxKind) -> bool {1725		kind == FOR_SPEC1726	}1727	fn cast(syntax: SyntaxNode) -> Option<Self> {1728		if Self::can_cast(syntax.kind()) {1729			Some(Self { syntax })1730		} else {1731			None1732		}1733	}1734	fn syntax(&self) -> &SyntaxNode {1735		&self.syntax1736	}1737}1738impl AstNode for ForObjSpec {1739	fn can_cast(kind: SyntaxKind) -> bool {1740		kind == FOR_OBJ_SPEC1741	}1742	fn cast(syntax: SyntaxNode) -> Option<Self> {1743		if Self::can_cast(syntax.kind()) {1744			Some(Self { syntax })1745		} else {1746			None1747		}1748	}1749	fn syntax(&self) -> &SyntaxNode {1750		&self.syntax1751	}1752}1753impl AstNode for IfSpec {1754	fn can_cast(kind: SyntaxKind) -> bool {1755		kind == IF_SPEC1756	}1757	fn cast(syntax: SyntaxNode) -> Option<Self> {1758		if Self::can_cast(syntax.kind()) {1759			Some(Self { syntax })1760		} else {1761			None1762		}1763	}1764	fn syntax(&self) -> &SyntaxNode {1765		&self.syntax1766	}1767}1768impl AstNode for BindDestruct {1769	fn can_cast(kind: SyntaxKind) -> bool {1770		kind == BIND_DESTRUCT1771	}1772	fn cast(syntax: SyntaxNode) -> Option<Self> {1773		if Self::can_cast(syntax.kind()) {1774			Some(Self { syntax })1775		} else {1776			None1777		}1778	}1779	fn syntax(&self) -> &SyntaxNode {1780		&self.syntax1781	}1782}1783impl AstNode for BindFunction {1784	fn can_cast(kind: SyntaxKind) -> bool {1785		kind == BIND_FUNCTION1786	}1787	fn cast(syntax: SyntaxNode) -> Option<Self> {1788		if Self::can_cast(syntax.kind()) {1789			Some(Self { syntax })1790		} else {1791			None1792		}1793	}1794	fn syntax(&self) -> &SyntaxNode {1795		&self.syntax1796	}1797}1798impl AstNode for Param {1799	fn can_cast(kind: SyntaxKind) -> bool {1800		kind == PARAM1801	}1802	fn cast(syntax: SyntaxNode) -> Option<Self> {1803		if Self::can_cast(syntax.kind()) {1804			Some(Self { syntax })1805		} else {1806			None1807		}1808	}1809	fn syntax(&self) -> &SyntaxNode {1810		&self.syntax1811	}1812}1813impl AstNode for DestructFull {1814	fn can_cast(kind: SyntaxKind) -> bool {1815		kind == DESTRUCT_FULL1816	}1817	fn cast(syntax: SyntaxNode) -> Option<Self> {1818		if Self::can_cast(syntax.kind()) {1819			Some(Self { syntax })1820		} else {1821			None1822		}1823	}1824	fn syntax(&self) -> &SyntaxNode {1825		&self.syntax1826	}1827}1828impl AstNode for DestructSkip {1829	fn can_cast(kind: SyntaxKind) -> bool {1830		kind == DESTRUCT_SKIP1831	}1832	fn cast(syntax: SyntaxNode) -> Option<Self> {1833		if Self::can_cast(syntax.kind()) {1834			Some(Self { syntax })1835		} else {1836			None1837		}1838	}1839	fn syntax(&self) -> &SyntaxNode {1840		&self.syntax1841	}1842}1843impl AstNode for DestructArray {1844	fn can_cast(kind: SyntaxKind) -> bool {1845		kind == DESTRUCT_ARRAY1846	}1847	fn cast(syntax: SyntaxNode) -> Option<Self> {1848		if Self::can_cast(syntax.kind()) {1849			Some(Self { syntax })1850		} else {1851			None1852		}1853	}1854	fn syntax(&self) -> &SyntaxNode {1855		&self.syntax1856	}1857}1858impl AstNode for DestructObject {1859	fn can_cast(kind: SyntaxKind) -> bool {1860		kind == DESTRUCT_OBJECT1861	}1862	fn cast(syntax: SyntaxNode) -> Option<Self> {1863		if Self::can_cast(syntax.kind()) {1864			Some(Self { syntax })1865		} else {1866			None1867		}1868	}1869	fn syntax(&self) -> &SyntaxNode {1870		&self.syntax1871	}1872}1873impl AstNode for DestructObjectField {1874	fn can_cast(kind: SyntaxKind) -> bool {1875		kind == DESTRUCT_OBJECT_FIELD1876	}1877	fn cast(syntax: SyntaxNode) -> Option<Self> {1878		if Self::can_cast(syntax.kind()) {1879			Some(Self { syntax })1880		} else {1881			None1882		}1883	}1884	fn syntax(&self) -> &SyntaxNode {1885		&self.syntax1886	}1887}1888impl AstNode for DestructRest {1889	fn can_cast(kind: SyntaxKind) -> bool {1890		kind == DESTRUCT_REST1891	}1892	fn cast(syntax: SyntaxNode) -> Option<Self> {1893		if Self::can_cast(syntax.kind()) {1894			Some(Self { syntax })1895		} else {1896			None1897		}1898	}1899	fn syntax(&self) -> &SyntaxNode {1900		&self.syntax1901	}1902}1903impl AstNode for DestructArrayElement {1904	fn can_cast(kind: SyntaxKind) -> bool {1905		kind == DESTRUCT_ARRAY_ELEMENT1906	}1907	fn cast(syntax: SyntaxNode) -> Option<Self> {1908		if Self::can_cast(syntax.kind()) {1909			Some(Self { syntax })1910		} else {1911			None1912		}1913	}1914	fn syntax(&self) -> &SyntaxNode {1915		&self.syntax1916	}1917}1918impl From<SuffixIndex> for Suffix {1919	fn from(node: SuffixIndex) -> Suffix {1920		Suffix::SuffixIndex(node)1921	}1922}1923impl From<SuffixIndexExpr> for Suffix {1924	fn from(node: SuffixIndexExpr) -> Suffix {1925		Suffix::SuffixIndexExpr(node)1926	}1927}1928impl From<SuffixSlice> for Suffix {1929	fn from(node: SuffixSlice) -> Suffix {1930		Suffix::SuffixSlice(node)1931	}1932}1933impl From<SuffixApply> for Suffix {1934	fn from(node: SuffixApply) -> Suffix {1935		Suffix::SuffixApply(node)1936	}1937}1938impl AstNode for Suffix {1939	fn can_cast(kind: SyntaxKind) -> bool {1940		match kind {1941			SUFFIX_INDEX | SUFFIX_INDEX_EXPR | SUFFIX_SLICE | SUFFIX_APPLY => true,1942			_ => false,1943		}1944	}1945	fn cast(syntax: SyntaxNode) -> Option<Self> {1946		let res = match syntax.kind() {1947			SUFFIX_INDEX => Suffix::SuffixIndex(SuffixIndex { syntax }),1948			SUFFIX_INDEX_EXPR => Suffix::SuffixIndexExpr(SuffixIndexExpr { syntax }),1949			SUFFIX_SLICE => Suffix::SuffixSlice(SuffixSlice { syntax }),1950			SUFFIX_APPLY => Suffix::SuffixApply(SuffixApply { syntax }),1951			_ => return None,1952		};1953		Some(res)1954	}1955	fn syntax(&self) -> &SyntaxNode {1956		match self {1957			Suffix::SuffixIndex(it) => &it.syntax,1958			Suffix::SuffixIndexExpr(it) => &it.syntax,1959			Suffix::SuffixSlice(it) => &it.syntax,1960			Suffix::SuffixApply(it) => &it.syntax,1961		}1962	}1963}1964impl From<BindDestruct> for Bind {1965	fn from(node: BindDestruct) -> Bind {1966		Bind::BindDestruct(node)1967	}1968}1969impl From<BindFunction> for Bind {1970	fn from(node: BindFunction) -> Bind {1971		Bind::BindFunction(node)1972	}1973}1974impl AstNode for Bind {1975	fn can_cast(kind: SyntaxKind) -> bool {1976		match kind {1977			BIND_DESTRUCT | BIND_FUNCTION => true,1978			_ => false,1979		}1980	}1981	fn cast(syntax: SyntaxNode) -> Option<Self> {1982		let res = match syntax.kind() {1983			BIND_DESTRUCT => Bind::BindDestruct(BindDestruct { syntax }),1984			BIND_FUNCTION => Bind::BindFunction(BindFunction { syntax }),1985			_ => return None,1986		};1987		Some(res)1988	}1989	fn syntax(&self) -> &SyntaxNode {1990		match self {1991			Bind::BindDestruct(it) => &it.syntax,1992			Bind::BindFunction(it) => &it.syntax,1993		}1994	}1995}1996impl From<StmtLocal> for Stmt {1997	fn from(node: StmtLocal) -> Stmt {1998		Stmt::StmtLocal(node)1999	}2000}2001impl From<StmtAssert> for Stmt {2002	fn from(node: StmtAssert) -> Stmt {2003		Stmt::StmtAssert(node)2004	}2005}2006impl AstNode for Stmt {2007	fn can_cast(kind: SyntaxKind) -> bool {2008		match kind {2009			STMT_LOCAL | STMT_ASSERT => true,2010			_ => false,2011		}2012	}2013	fn cast(syntax: SyntaxNode) -> Option<Self> {2014		let res = match syntax.kind() {2015			STMT_LOCAL => Stmt::StmtLocal(StmtLocal { syntax }),2016			STMT_ASSERT => Stmt::StmtAssert(StmtAssert { syntax }),2017			_ => return None,2018		};2019		Some(res)2020	}2021	fn syntax(&self) -> &SyntaxNode {2022		match self {2023			Stmt::StmtLocal(it) => &it.syntax,2024			Stmt::StmtAssert(it) => &it.syntax,2025		}2026	}2027}2028impl From<ObjBodyComp> for ObjBody {2029	fn from(node: ObjBodyComp) -> ObjBody {2030		ObjBody::ObjBodyComp(node)2031	}2032}2033impl From<ObjBodyMemberList> for ObjBody {2034	fn from(node: ObjBodyMemberList) -> ObjBody {2035		ObjBody::ObjBodyMemberList(node)2036	}2037}2038impl AstNode for ObjBody {2039	fn can_cast(kind: SyntaxKind) -> bool {2040		match kind {2041			OBJ_BODY_COMP | OBJ_BODY_MEMBER_LIST => true,2042			_ => false,2043		}2044	}2045	fn cast(syntax: SyntaxNode) -> Option<Self> {2046		let res = match syntax.kind() {2047			OBJ_BODY_COMP => ObjBody::ObjBodyComp(ObjBodyComp { syntax }),2048			OBJ_BODY_MEMBER_LIST => ObjBody::ObjBodyMemberList(ObjBodyMemberList { syntax }),2049			_ => return None,2050		};2051		Some(res)2052	}2053	fn syntax(&self) -> &SyntaxNode {2054		match self {2055			ObjBody::ObjBodyComp(it) => &it.syntax,2056			ObjBody::ObjBodyMemberList(it) => &it.syntax,2057		}2058	}2059}2060impl From<ForSpec> for CompSpec {2061	fn from(node: ForSpec) -> CompSpec {2062		CompSpec::ForSpec(node)2063	}2064}2065impl From<ForObjSpec> for CompSpec {2066	fn from(node: ForObjSpec) -> CompSpec {2067		CompSpec::ForObjSpec(node)2068	}2069}2070impl From<IfSpec> for CompSpec {2071	fn from(node: IfSpec) -> CompSpec {2072		CompSpec::IfSpec(node)2073	}2074}2075impl AstNode for CompSpec {2076	fn can_cast(kind: SyntaxKind) -> bool {2077		match kind {2078			FOR_SPEC | FOR_OBJ_SPEC | IF_SPEC => true,2079			_ => false,2080		}2081	}2082	fn cast(syntax: SyntaxNode) -> Option<Self> {2083		let res = match syntax.kind() {2084			FOR_SPEC => CompSpec::ForSpec(ForSpec { syntax }),2085			FOR_OBJ_SPEC => CompSpec::ForObjSpec(ForObjSpec { syntax }),2086			IF_SPEC => CompSpec::IfSpec(IfSpec { syntax }),2087			_ => return None,2088		};2089		Some(res)2090	}2091	fn syntax(&self) -> &SyntaxNode {2092		match self {2093			CompSpec::ForSpec(it) => &it.syntax,2094			CompSpec::ForObjSpec(it) => &it.syntax,2095			CompSpec::IfSpec(it) => &it.syntax,2096		}2097	}2098}2099impl From<ExprBinary> for ExprBase {2100	fn from(node: ExprBinary) -> ExprBase {2101		ExprBase::ExprBinary(node)2102	}2103}2104impl From<ExprUnary> for ExprBase {2105	fn from(node: ExprUnary) -> ExprBase {2106		ExprBase::ExprUnary(node)2107	}2108}2109impl From<ExprObjExtend> for ExprBase {2110	fn from(node: ExprObjExtend) -> ExprBase {2111		ExprBase::ExprObjExtend(node)2112	}2113}2114impl From<ExprParened> for ExprBase {2115	fn from(node: ExprParened) -> ExprBase {2116		ExprBase::ExprParened(node)2117	}2118}2119impl From<ExprString> for ExprBase {2120	fn from(node: ExprString) -> ExprBase {2121		ExprBase::ExprString(node)2122	}2123}2124impl From<ExprNumber> for ExprBase {2125	fn from(node: ExprNumber) -> ExprBase {2126		ExprBase::ExprNumber(node)2127	}2128}2129impl From<ExprLiteral> for ExprBase {2130	fn from(node: ExprLiteral) -> ExprBase {2131		ExprBase::ExprLiteral(node)2132	}2133}2134impl From<ExprArray> for ExprBase {2135	fn from(node: ExprArray) -> ExprBase {2136		ExprBase::ExprArray(node)2137	}2138}2139impl From<ExprObject> for ExprBase {2140	fn from(node: ExprObject) -> ExprBase {2141		ExprBase::ExprObject(node)2142	}2143}2144impl From<ExprArrayComp> for ExprBase {2145	fn from(node: ExprArrayComp) -> ExprBase {2146		ExprBase::ExprArrayComp(node)2147	}2148}2149impl From<ExprImport> for ExprBase {2150	fn from(node: ExprImport) -> ExprBase {2151		ExprBase::ExprImport(node)2152	}2153}2154impl From<ExprVar> for ExprBase {2155	fn from(node: ExprVar) -> ExprBase {2156		ExprBase::ExprVar(node)2157	}2158}2159impl From<ExprIfThenElse> for ExprBase {2160	fn from(node: ExprIfThenElse) -> ExprBase {2161		ExprBase::ExprIfThenElse(node)2162	}2163}2164impl From<ExprFunction> for ExprBase {2165	fn from(node: ExprFunction) -> ExprBase {2166		ExprBase::ExprFunction(node)2167	}2168}2169impl From<ExprError> for ExprBase {2170	fn from(node: ExprError) -> ExprBase {2171		ExprBase::ExprError(node)2172	}2173}2174impl AstNode for ExprBase {2175	fn can_cast(kind: SyntaxKind) -> bool {2176		match kind {2177			EXPR_BINARY | EXPR_UNARY | EXPR_OBJ_EXTEND | EXPR_PARENED | EXPR_STRING2178			| EXPR_NUMBER | EXPR_LITERAL | EXPR_ARRAY | EXPR_OBJECT | EXPR_ARRAY_COMP2179			| EXPR_IMPORT | EXPR_VAR | EXPR_IF_THEN_ELSE | EXPR_FUNCTION | EXPR_ERROR => true,2180			_ => false,2181		}2182	}2183	fn cast(syntax: SyntaxNode) -> Option<Self> {2184		let res = match syntax.kind() {2185			EXPR_BINARY => ExprBase::ExprBinary(ExprBinary { syntax }),2186			EXPR_UNARY => ExprBase::ExprUnary(ExprUnary { syntax }),2187			EXPR_OBJ_EXTEND => ExprBase::ExprObjExtend(ExprObjExtend { syntax }),2188			EXPR_PARENED => ExprBase::ExprParened(ExprParened { syntax }),2189			EXPR_STRING => ExprBase::ExprString(ExprString { syntax }),2190			EXPR_NUMBER => ExprBase::ExprNumber(ExprNumber { syntax }),2191			EXPR_LITERAL => ExprBase::ExprLiteral(ExprLiteral { syntax }),2192			EXPR_ARRAY => ExprBase::ExprArray(ExprArray { syntax }),2193			EXPR_OBJECT => ExprBase::ExprObject(ExprObject { syntax }),2194			EXPR_ARRAY_COMP => ExprBase::ExprArrayComp(ExprArrayComp { syntax }),2195			EXPR_IMPORT => ExprBase::ExprImport(ExprImport { syntax }),2196			EXPR_VAR => ExprBase::ExprVar(ExprVar { syntax }),2197			EXPR_IF_THEN_ELSE => ExprBase::ExprIfThenElse(ExprIfThenElse { syntax }),2198			EXPR_FUNCTION => ExprBase::ExprFunction(ExprFunction { syntax }),2199			EXPR_ERROR => ExprBase::ExprError(ExprError { syntax }),2200			_ => return None,2201		};2202		Some(res)2203	}2204	fn syntax(&self) -> &SyntaxNode {2205		match self {2206			ExprBase::ExprBinary(it) => &it.syntax,2207			ExprBase::ExprUnary(it) => &it.syntax,2208			ExprBase::ExprObjExtend(it) => &it.syntax,2209			ExprBase::ExprParened(it) => &it.syntax,2210			ExprBase::ExprString(it) => &it.syntax,2211			ExprBase::ExprNumber(it) => &it.syntax,2212			ExprBase::ExprLiteral(it) => &it.syntax,2213			ExprBase::ExprArray(it) => &it.syntax,2214			ExprBase::ExprObject(it) => &it.syntax,2215			ExprBase::ExprArrayComp(it) => &it.syntax,2216			ExprBase::ExprImport(it) => &it.syntax,2217			ExprBase::ExprVar(it) => &it.syntax,2218			ExprBase::ExprIfThenElse(it) => &it.syntax,2219			ExprBase::ExprFunction(it) => &it.syntax,2220			ExprBase::ExprError(it) => &it.syntax,2221		}2222	}2223}2224impl From<MemberBindStmt> for MemberComp {2225	fn from(node: MemberBindStmt) -> MemberComp {2226		MemberComp::MemberBindStmt(node)2227	}2228}2229impl From<MemberFieldNormal> for MemberComp {2230	fn from(node: MemberFieldNormal) -> MemberComp {2231		MemberComp::MemberFieldNormal(node)2232	}2233}2234impl From<MemberFieldMethod> for MemberComp {2235	fn from(node: MemberFieldMethod) -> MemberComp {2236		MemberComp::MemberFieldMethod(node)2237	}2238}2239impl AstNode for MemberComp {2240	fn can_cast(kind: SyntaxKind) -> bool {2241		match kind {2242			MEMBER_BIND_STMT | MEMBER_FIELD_NORMAL | MEMBER_FIELD_METHOD => true,2243			_ => false,2244		}2245	}2246	fn cast(syntax: SyntaxNode) -> Option<Self> {2247		let res = match syntax.kind() {2248			MEMBER_BIND_STMT => MemberComp::MemberBindStmt(MemberBindStmt { syntax }),2249			MEMBER_FIELD_NORMAL => MemberComp::MemberFieldNormal(MemberFieldNormal { syntax }),2250			MEMBER_FIELD_METHOD => MemberComp::MemberFieldMethod(MemberFieldMethod { syntax }),2251			_ => return None,2252		};2253		Some(res)2254	}2255	fn syntax(&self) -> &SyntaxNode {2256		match self {2257			MemberComp::MemberBindStmt(it) => &it.syntax,2258			MemberComp::MemberFieldNormal(it) => &it.syntax,2259			MemberComp::MemberFieldMethod(it) => &it.syntax,2260		}2261	}2262}2263impl From<MemberBindStmt> for Member {2264	fn from(node: MemberBindStmt) -> Member {2265		Member::MemberBindStmt(node)2266	}2267}2268impl From<MemberAssertStmt> for Member {2269	fn from(node: MemberAssertStmt) -> Member {2270		Member::MemberAssertStmt(node)2271	}2272}2273impl From<MemberFieldNormal> for Member {2274	fn from(node: MemberFieldNormal) -> Member {2275		Member::MemberFieldNormal(node)2276	}2277}2278impl From<MemberFieldMethod> for Member {2279	fn from(node: MemberFieldMethod) -> Member {2280		Member::MemberFieldMethod(node)2281	}2282}2283impl AstNode for Member {2284	fn can_cast(kind: SyntaxKind) -> bool {2285		match kind {2286			MEMBER_BIND_STMT | MEMBER_ASSERT_STMT | MEMBER_FIELD_NORMAL | MEMBER_FIELD_METHOD => {2287				true2288			}2289			_ => false,2290		}2291	}2292	fn cast(syntax: SyntaxNode) -> Option<Self> {2293		let res = match syntax.kind() {2294			MEMBER_BIND_STMT => Member::MemberBindStmt(MemberBindStmt { syntax }),2295			MEMBER_ASSERT_STMT => Member::MemberAssertStmt(MemberAssertStmt { syntax }),2296			MEMBER_FIELD_NORMAL => Member::MemberFieldNormal(MemberFieldNormal { syntax }),2297			MEMBER_FIELD_METHOD => Member::MemberFieldMethod(MemberFieldMethod { syntax }),2298			_ => return None,2299		};2300		Some(res)2301	}2302	fn syntax(&self) -> &SyntaxNode {2303		match self {2304			Member::MemberBindStmt(it) => &it.syntax,2305			Member::MemberAssertStmt(it) => &it.syntax,2306			Member::MemberFieldNormal(it) => &it.syntax,2307			Member::MemberFieldMethod(it) => &it.syntax,2308		}2309	}2310}2311impl From<FieldNameFixed> for FieldName {2312	fn from(node: FieldNameFixed) -> FieldName {2313		FieldName::FieldNameFixed(node)2314	}2315}2316impl From<FieldNameDynamic> for FieldName {2317	fn from(node: FieldNameDynamic) -> FieldName {2318		FieldName::FieldNameDynamic(node)2319	}2320}2321impl AstNode for FieldName {2322	fn can_cast(kind: SyntaxKind) -> bool {2323		match kind {2324			FIELD_NAME_FIXED | FIELD_NAME_DYNAMIC => true,2325			_ => false,2326		}2327	}2328	fn cast(syntax: SyntaxNode) -> Option<Self> {2329		let res = match syntax.kind() {2330			FIELD_NAME_FIXED => FieldName::FieldNameFixed(FieldNameFixed { syntax }),2331			FIELD_NAME_DYNAMIC => FieldName::FieldNameDynamic(FieldNameDynamic { syntax }),2332			_ => return None,2333		};2334		Some(res)2335	}2336	fn syntax(&self) -> &SyntaxNode {2337		match self {2338			FieldName::FieldNameFixed(it) => &it.syntax,2339			FieldName::FieldNameDynamic(it) => &it.syntax,2340		}2341	}2342}2343impl From<DestructFull> for Destruct {2344	fn from(node: DestructFull) -> Destruct {2345		Destruct::DestructFull(node)2346	}2347}2348impl From<DestructSkip> for Destruct {2349	fn from(node: DestructSkip) -> Destruct {2350		Destruct::DestructSkip(node)2351	}2352}2353impl From<DestructArray> for Destruct {2354	fn from(node: DestructArray) -> Destruct {2355		Destruct::DestructArray(node)2356	}2357}2358impl From<DestructObject> for Destruct {2359	fn from(node: DestructObject) -> Destruct {2360		Destruct::DestructObject(node)2361	}2362}2363impl AstNode for Destruct {2364	fn can_cast(kind: SyntaxKind) -> bool {2365		match kind {2366			DESTRUCT_FULL | DESTRUCT_SKIP | DESTRUCT_ARRAY | DESTRUCT_OBJECT => true,2367			_ => false,2368		}2369	}2370	fn cast(syntax: SyntaxNode) -> Option<Self> {2371		let res = match syntax.kind() {2372			DESTRUCT_FULL => Destruct::DestructFull(DestructFull { syntax }),2373			DESTRUCT_SKIP => Destruct::DestructSkip(DestructSkip { syntax }),2374			DESTRUCT_ARRAY => Destruct::DestructArray(DestructArray { syntax }),2375			DESTRUCT_OBJECT => Destruct::DestructObject(DestructObject { syntax }),2376			_ => return None,2377		};2378		Some(res)2379	}2380	fn syntax(&self) -> &SyntaxNode {2381		match self {2382			Destruct::DestructFull(it) => &it.syntax,2383			Destruct::DestructSkip(it) => &it.syntax,2384			Destruct::DestructArray(it) => &it.syntax,2385			Destruct::DestructObject(it) => &it.syntax,2386		}2387	}2388}2389impl From<DestructArrayElement> for DestructArrayPart {2390	fn from(node: DestructArrayElement) -> DestructArrayPart {2391		DestructArrayPart::DestructArrayElement(node)2392	}2393}2394impl From<DestructRest> for DestructArrayPart {2395	fn from(node: DestructRest) -> DestructArrayPart {2396		DestructArrayPart::DestructRest(node)2397	}2398}2399impl AstNode for DestructArrayPart {2400	fn can_cast(kind: SyntaxKind) -> bool {2401		match kind {2402			DESTRUCT_ARRAY_ELEMENT | DESTRUCT_REST => true,2403			_ => false,2404		}2405	}2406	fn cast(syntax: SyntaxNode) -> Option<Self> {2407		let res = match syntax.kind() {2408			DESTRUCT_ARRAY_ELEMENT => {2409				DestructArrayPart::DestructArrayElement(DestructArrayElement { syntax })2410			}2411			DESTRUCT_REST => DestructArrayPart::DestructRest(DestructRest { syntax }),2412			_ => return None,2413		};2414		Some(res)2415	}2416	fn syntax(&self) -> &SyntaxNode {2417		match self {2418			DestructArrayPart::DestructArrayElement(it) => &it.syntax,2419			DestructArrayPart::DestructRest(it) => &it.syntax,2420		}2421	}2422}2423impl AstToken for BinaryOperator {2424	fn can_cast(kind: SyntaxKind) -> bool {2425		BinaryOperatorKind::can_cast(kind)2426	}2427	fn cast(syntax: SyntaxToken) -> Option<Self> {2428		let kind = BinaryOperatorKind::cast(syntax.kind())?;2429		Some(BinaryOperator { syntax, kind })2430	}2431	fn syntax(&self) -> &SyntaxToken {2432		&self.syntax2433	}2434}2435impl BinaryOperatorKind {2436	fn can_cast(kind: SyntaxKind) -> bool {2437		match kind {2438			OR | NULL_COAELSE | AND | BIT_OR | BIT_XOR | BIT_AND | EQ | NE | LT | GT | LE | GE2439			| IN_KW | LHS | RHS | PLUS | MINUS | MUL | DIV | MODULO | META_OBJECT_APPLY2440			| ERROR_NO_OPERATOR => true,2441			_ => false,2442		}2443	}2444	pub fn cast(kind: SyntaxKind) -> Option<Self> {2445		let res = match kind {2446			OR => Self::Or,2447			NULL_COAELSE => Self::NullCoaelse,2448			AND => Self::And,2449			BIT_OR => Self::BitOr,2450			BIT_XOR => Self::BitXor,2451			BIT_AND => Self::BitAnd,2452			EQ => Self::Eq,2453			NE => Self::Ne,2454			LT => Self::Lt,2455			GT => Self::Gt,2456			LE => Self::Le,2457			GE => Self::Ge,2458			IN_KW => Self::InKw,2459			LHS => Self::Lhs,2460			RHS => Self::Rhs,2461			PLUS => Self::Plus,2462			MINUS => Self::Minus,2463			MUL => Self::Mul,2464			DIV => Self::Div,2465			MODULO => Self::Modulo,2466			META_OBJECT_APPLY => Self::MetaObjectApply,2467			ERROR_NO_OPERATOR => Self::ErrorNoOperator,2468			_ => return None,2469		};2470		Some(res)2471	}2472}2473impl BinaryOperator {2474	pub fn kind(&self) -> BinaryOperatorKind {2475		self.kind2476	}2477}2478impl std::fmt::Display for BinaryOperator {2479	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2480		std::fmt::Display::fmt(self.syntax(), f)2481	}2482}2483impl AstToken for UnaryOperator {2484	fn can_cast(kind: SyntaxKind) -> bool {2485		UnaryOperatorKind::can_cast(kind)2486	}2487	fn cast(syntax: SyntaxToken) -> Option<Self> {2488		let kind = UnaryOperatorKind::cast(syntax.kind())?;2489		Some(UnaryOperator { syntax, kind })2490	}2491	fn syntax(&self) -> &SyntaxToken {2492		&self.syntax2493	}2494}2495impl UnaryOperatorKind {2496	fn can_cast(kind: SyntaxKind) -> bool {2497		match kind {2498			MINUS | NOT | BIT_NOT | PLUS => true,2499			_ => false,2500		}2501	}2502	pub fn cast(kind: SyntaxKind) -> Option<Self> {2503		let res = match kind {2504			MINUS => Self::Minus,2505			NOT => Self::Not,2506			BIT_NOT => Self::BitNot,2507			PLUS => Self::Plus,2508			_ => return None,2509		};2510		Some(res)2511	}2512}2513impl UnaryOperator {2514	pub fn kind(&self) -> UnaryOperatorKind {2515		self.kind2516	}2517}2518impl std::fmt::Display for UnaryOperator {2519	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2520		std::fmt::Display::fmt(self.syntax(), f)2521	}2522}2523impl AstToken for Literal {2524	fn can_cast(kind: SyntaxKind) -> bool {2525		LiteralKind::can_cast(kind)2526	}2527	fn cast(syntax: SyntaxToken) -> Option<Self> {2528		let kind = LiteralKind::cast(syntax.kind())?;2529		Some(Literal { syntax, kind })2530	}2531	fn syntax(&self) -> &SyntaxToken {2532		&self.syntax2533	}2534}2535impl LiteralKind {2536	fn can_cast(kind: SyntaxKind) -> bool {2537		match kind {2538			NULL_KW | TRUE_KW | FALSE_KW | SELF_KW | DOLLAR | SUPER_KW => true,2539			_ => false,2540		}2541	}2542	pub fn cast(kind: SyntaxKind) -> Option<Self> {2543		let res = match kind {2544			NULL_KW => Self::NullKw,2545			TRUE_KW => Self::TrueKw,2546			FALSE_KW => Self::FalseKw,2547			SELF_KW => Self::SelfKw,2548			DOLLAR => Self::Dollar,2549			SUPER_KW => Self::SuperKw,2550			_ => return None,2551		};2552		Some(res)2553	}2554}2555impl Literal {2556	pub fn kind(&self) -> LiteralKind {2557		self.kind2558	}2559}2560impl std::fmt::Display for Literal {2561	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2562		std::fmt::Display::fmt(self.syntax(), f)2563	}2564}2565impl AstToken for Text {2566	fn can_cast(kind: SyntaxKind) -> bool {2567		TextKind::can_cast(kind)2568	}2569	fn cast(syntax: SyntaxToken) -> Option<Self> {2570		let kind = TextKind::cast(syntax.kind())?;2571		Some(Text { syntax, kind })2572	}2573	fn syntax(&self) -> &SyntaxToken {2574		&self.syntax2575	}2576}2577impl TextKind {2578	fn can_cast(kind: SyntaxKind) -> bool {2579		match kind {2580			STRING_DOUBLE2581			| ERROR_STRING_DOUBLE_UNTERMINATED2582			| STRING_SINGLE2583			| ERROR_STRING_SINGLE_UNTERMINATED2584			| STRING_DOUBLE_VERBATIM2585			| ERROR_STRING_DOUBLE_VERBATIM_UNTERMINATED2586			| STRING_SINGLE_VERBATIM2587			| ERROR_STRING_SINGLE_VERBATIM_UNTERMINATED2588			| ERROR_STRING_VERBATIM_MISSING_QUOTES2589			| STRING_BLOCK2590			| ERROR_STRING_BLOCK_UNEXPECTED_END2591			| ERROR_STRING_BLOCK_MISSING_NEW_LINE2592			| ERROR_STRING_BLOCK_MISSING_TERMINATION2593			| ERROR_STRING_BLOCK_MISSING_INDENT => true,2594			_ => false,2595		}2596	}2597	pub fn cast(kind: SyntaxKind) -> Option<Self> {2598		let res = match kind {2599			STRING_DOUBLE => Self::StringDouble,2600			ERROR_STRING_DOUBLE_UNTERMINATED => Self::ErrorStringDoubleUnterminated,2601			STRING_SINGLE => Self::StringSingle,2602			ERROR_STRING_SINGLE_UNTERMINATED => Self::ErrorStringSingleUnterminated,2603			STRING_DOUBLE_VERBATIM => Self::StringDoubleVerbatim,2604			ERROR_STRING_DOUBLE_VERBATIM_UNTERMINATED => {2605				Self::ErrorStringDoubleVerbatimUnterminated2606			}2607			STRING_SINGLE_VERBATIM => Self::StringSingleVerbatim,2608			ERROR_STRING_SINGLE_VERBATIM_UNTERMINATED => {2609				Self::ErrorStringSingleVerbatimUnterminated2610			}2611			ERROR_STRING_VERBATIM_MISSING_QUOTES => Self::ErrorStringVerbatimMissingQuotes,2612			STRING_BLOCK => Self::StringBlock,2613			ERROR_STRING_BLOCK_UNEXPECTED_END => Self::ErrorStringBlockUnexpectedEnd,2614			ERROR_STRING_BLOCK_MISSING_NEW_LINE => Self::ErrorStringBlockMissingNewLine,2615			ERROR_STRING_BLOCK_MISSING_TERMINATION => Self::ErrorStringBlockMissingTermination,2616			ERROR_STRING_BLOCK_MISSING_INDENT => Self::ErrorStringBlockMissingIndent,2617			_ => return None,2618		};2619		Some(res)2620	}2621}2622impl Text {2623	pub fn kind(&self) -> TextKind {2624		self.kind2625	}2626}2627impl std::fmt::Display for Text {2628	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2629		std::fmt::Display::fmt(self.syntax(), f)2630	}2631}2632impl AstToken for Number {2633	fn can_cast(kind: SyntaxKind) -> bool {2634		NumberKind::can_cast(kind)2635	}2636	fn cast(syntax: SyntaxToken) -> Option<Self> {2637		let kind = NumberKind::cast(syntax.kind())?;2638		Some(Number { syntax, kind })2639	}2640	fn syntax(&self) -> &SyntaxToken {2641		&self.syntax2642	}2643}2644impl NumberKind {2645	fn can_cast(kind: SyntaxKind) -> bool {2646		match kind {2647			FLOAT2648			| ERROR_FLOAT_JUNK_AFTER_POINT2649			| ERROR_FLOAT_JUNK_AFTER_EXPONENT2650			| ERROR_FLOAT_JUNK_AFTER_EXPONENT_SIGN => true,2651			_ => false,2652		}2653	}2654	pub fn cast(kind: SyntaxKind) -> Option<Self> {2655		let res = match kind {2656			FLOAT => Self::Float,2657			ERROR_FLOAT_JUNK_AFTER_POINT => Self::ErrorFloatJunkAfterPoint,2658			ERROR_FLOAT_JUNK_AFTER_EXPONENT => Self::ErrorFloatJunkAfterExponent,2659			ERROR_FLOAT_JUNK_AFTER_EXPONENT_SIGN => Self::ErrorFloatJunkAfterExponentSign,2660			_ => return None,2661		};2662		Some(res)2663	}2664}2665impl Number {2666	pub fn kind(&self) -> NumberKind {2667		self.kind2668	}2669}2670impl std::fmt::Display for Number {2671	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2672		std::fmt::Display::fmt(self.syntax(), f)2673	}2674}2675impl AstToken for ImportKind {2676	fn can_cast(kind: SyntaxKind) -> bool {2677		ImportKindKind::can_cast(kind)2678	}2679	fn cast(syntax: SyntaxToken) -> Option<Self> {2680		let kind = ImportKindKind::cast(syntax.kind())?;2681		Some(ImportKind { syntax, kind })2682	}2683	fn syntax(&self) -> &SyntaxToken {2684		&self.syntax2685	}2686}2687impl ImportKindKind {2688	fn can_cast(kind: SyntaxKind) -> bool {2689		match kind {2690			IMPORTSTR_KW | IMPORTBIN_KW | IMPORT_KW => true,2691			_ => false,2692		}2693	}2694	pub fn cast(kind: SyntaxKind) -> Option<Self> {2695		let res = match kind {2696			IMPORTSTR_KW => Self::ImportstrKw,2697			IMPORTBIN_KW => Self::ImportbinKw,2698			IMPORT_KW => Self::ImportKw,2699			_ => return None,2700		};2701		Some(res)2702	}2703}2704impl ImportKind {2705	pub fn kind(&self) -> ImportKindKind {2706		self.kind2707	}2708}2709impl std::fmt::Display for ImportKind {2710	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2711		std::fmt::Display::fmt(self.syntax(), f)2712	}2713}2714impl AstToken for Trivia {2715	fn can_cast(kind: SyntaxKind) -> bool {2716		TriviaKind::can_cast(kind)2717	}2718	fn cast(syntax: SyntaxToken) -> Option<Self> {2719		let kind = TriviaKind::cast(syntax.kind())?;2720		Some(Trivia { syntax, kind })2721	}2722	fn syntax(&self) -> &SyntaxToken {2723		&self.syntax2724	}2725}2726impl TriviaKind {2727	fn can_cast(kind: SyntaxKind) -> bool {2728		match kind {2729			WHITESPACE2730			| MULTI_LINE_COMMENT2731			| ERROR_COMMENT_TOO_SHORT2732			| ERROR_COMMENT_UNTERMINATED2733			| SINGLE_LINE_HASH_COMMENT2734			| SINGLE_LINE_SLASH_COMMENT => true,2735			_ => false,2736		}2737	}2738	pub fn cast(kind: SyntaxKind) -> Option<Self> {2739		let res = match kind {2740			WHITESPACE => Self::Whitespace,2741			MULTI_LINE_COMMENT => Self::MultiLineComment,2742			ERROR_COMMENT_TOO_SHORT => Self::ErrorCommentTooShort,2743			ERROR_COMMENT_UNTERMINATED => Self::ErrorCommentUnterminated,2744			SINGLE_LINE_HASH_COMMENT => Self::SingleLineHashComment,2745			SINGLE_LINE_SLASH_COMMENT => Self::SingleLineSlashComment,2746			_ => return None,2747		};2748		Some(res)2749	}2750}2751impl Trivia {2752	pub fn kind(&self) -> TriviaKind {2753		self.kind2754	}2755}2756impl std::fmt::Display for Trivia {2757	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2758		std::fmt::Display::fmt(self.syntax(), f)2759	}2760}2761impl AstToken for CustomError {2762	fn can_cast(kind: SyntaxKind) -> bool {2763		CustomErrorKind::can_cast(kind)2764	}2765	fn cast(syntax: SyntaxToken) -> Option<Self> {2766		let kind = CustomErrorKind::cast(syntax.kind())?;2767		Some(CustomError { syntax, kind })2768	}2769	fn syntax(&self) -> &SyntaxToken {2770		&self.syntax2771	}2772}2773impl CustomErrorKind {2774	fn can_cast(kind: SyntaxKind) -> bool {2775		match kind {2776			ERROR_MISSING_TOKEN | ERROR_UNEXPECTED_TOKEN | ERROR_CUSTOM => true,2777			_ => false,2778		}2779	}2780	pub fn cast(kind: SyntaxKind) -> Option<Self> {2781		let res = match kind {2782			ERROR_MISSING_TOKEN => Self::ErrorMissingToken,2783			ERROR_UNEXPECTED_TOKEN => Self::ErrorUnexpectedToken,2784			ERROR_CUSTOM => Self::ErrorCustom,2785			_ => return None,2786		};2787		Some(res)2788	}2789}2790impl CustomError {2791	pub fn kind(&self) -> CustomErrorKind {2792		self.kind2793	}2794}2795impl std::fmt::Display for CustomError {2796	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2797		std::fmt::Display::fmt(self.syntax(), f)2798	}2799}2800impl std::fmt::Display for Suffix {2801	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2802		std::fmt::Display::fmt(self.syntax(), f)2803	}2804}2805impl std::fmt::Display for Bind {2806	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2807		std::fmt::Display::fmt(self.syntax(), f)2808	}2809}2810impl std::fmt::Display for Stmt {2811	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2812		std::fmt::Display::fmt(self.syntax(), f)2813	}2814}2815impl std::fmt::Display for ObjBody {2816	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2817		std::fmt::Display::fmt(self.syntax(), f)2818	}2819}2820impl std::fmt::Display for CompSpec {2821	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2822		std::fmt::Display::fmt(self.syntax(), f)2823	}2824}2825impl std::fmt::Display for ExprBase {2826	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2827		std::fmt::Display::fmt(self.syntax(), f)2828	}2829}2830impl std::fmt::Display for MemberComp {2831	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2832		std::fmt::Display::fmt(self.syntax(), f)2833	}2834}2835impl std::fmt::Display for Member {2836	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2837		std::fmt::Display::fmt(self.syntax(), f)2838	}2839}2840impl std::fmt::Display for FieldName {2841	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2842		std::fmt::Display::fmt(self.syntax(), f)2843	}2844}2845impl std::fmt::Display for Destruct {2846	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2847		std::fmt::Display::fmt(self.syntax(), f)2848	}2849}2850impl std::fmt::Display for DestructArrayPart {2851	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2852		std::fmt::Display::fmt(self.syntax(), f)2853	}2854}2855impl std::fmt::Display for SourceFile {2856	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2857		std::fmt::Display::fmt(self.syntax(), f)2858	}2859}2860impl std::fmt::Display for Expr {2861	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2862		std::fmt::Display::fmt(self.syntax(), f)2863	}2864}2865impl std::fmt::Display for SuffixIndex {2866	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2867		std::fmt::Display::fmt(self.syntax(), f)2868	}2869}2870impl std::fmt::Display for Name {2871	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2872		std::fmt::Display::fmt(self.syntax(), f)2873	}2874}2875impl std::fmt::Display for SuffixIndexExpr {2876	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2877		std::fmt::Display::fmt(self.syntax(), f)2878	}2879}2880impl std::fmt::Display for SuffixSlice {2881	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2882		std::fmt::Display::fmt(self.syntax(), f)2883	}2884}2885impl std::fmt::Display for SliceDesc {2886	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2887		std::fmt::Display::fmt(self.syntax(), f)2888	}2889}2890impl std::fmt::Display for SuffixApply {2891	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2892		std::fmt::Display::fmt(self.syntax(), f)2893	}2894}2895impl std::fmt::Display for ArgsDesc {2896	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2897		std::fmt::Display::fmt(self.syntax(), f)2898	}2899}2900impl std::fmt::Display for StmtLocal {2901	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2902		std::fmt::Display::fmt(self.syntax(), f)2903	}2904}2905impl std::fmt::Display for StmtAssert {2906	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2907		std::fmt::Display::fmt(self.syntax(), f)2908	}2909}2910impl std::fmt::Display for Assertion {2911	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2912		std::fmt::Display::fmt(self.syntax(), f)2913	}2914}2915impl std::fmt::Display for ExprBinary {2916	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2917		std::fmt::Display::fmt(self.syntax(), f)2918	}2919}2920impl std::fmt::Display for ExprUnary {2921	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2922		std::fmt::Display::fmt(self.syntax(), f)2923	}2924}2925impl std::fmt::Display for ExprObjExtend {2926	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2927		std::fmt::Display::fmt(self.syntax(), f)2928	}2929}2930impl std::fmt::Display for ExprParened {2931	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2932		std::fmt::Display::fmt(self.syntax(), f)2933	}2934}2935impl std::fmt::Display for ExprLiteral {2936	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2937		std::fmt::Display::fmt(self.syntax(), f)2938	}2939}2940impl std::fmt::Display for ExprString {2941	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2942		std::fmt::Display::fmt(self.syntax(), f)2943	}2944}2945impl std::fmt::Display for ExprNumber {2946	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2947		std::fmt::Display::fmt(self.syntax(), f)2948	}2949}2950impl std::fmt::Display for ExprArray {2951	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2952		std::fmt::Display::fmt(self.syntax(), f)2953	}2954}2955impl std::fmt::Display for ExprObject {2956	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2957		std::fmt::Display::fmt(self.syntax(), f)2958	}2959}2960impl std::fmt::Display for ExprArrayComp {2961	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2962		std::fmt::Display::fmt(self.syntax(), f)2963	}2964}2965impl std::fmt::Display for ExprImport {2966	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2967		std::fmt::Display::fmt(self.syntax(), f)2968	}2969}2970impl std::fmt::Display for ExprVar {2971	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2972		std::fmt::Display::fmt(self.syntax(), f)2973	}2974}2975impl std::fmt::Display for ExprIfThenElse {2976	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2977		std::fmt::Display::fmt(self.syntax(), f)2978	}2979}2980impl std::fmt::Display for TrueExpr {2981	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2982		std::fmt::Display::fmt(self.syntax(), f)2983	}2984}2985impl std::fmt::Display for FalseExpr {2986	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2987		std::fmt::Display::fmt(self.syntax(), f)2988	}2989}2990impl std::fmt::Display for ExprFunction {2991	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2992		std::fmt::Display::fmt(self.syntax(), f)2993	}2994}2995impl std::fmt::Display for ParamsDesc {2996	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2997		std::fmt::Display::fmt(self.syntax(), f)2998	}2999}3000impl std::fmt::Display for ExprError {3001	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3002		std::fmt::Display::fmt(self.syntax(), f)3003	}3004}3005impl std::fmt::Display for SliceDescEnd {3006	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3007		std::fmt::Display::fmt(self.syntax(), f)3008	}3009}3010impl std::fmt::Display for SliceDescStep {3011	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3012		std::fmt::Display::fmt(self.syntax(), f)3013	}3014}3015impl std::fmt::Display for Arg {3016	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3017		std::fmt::Display::fmt(self.syntax(), f)3018	}3019}3020impl std::fmt::Display for ObjBodyComp {3021	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3022		std::fmt::Display::fmt(self.syntax(), f)3023	}3024}3025impl std::fmt::Display for ObjBodyMemberList {3026	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3027		std::fmt::Display::fmt(self.syntax(), f)3028	}3029}3030impl std::fmt::Display for MemberBindStmt {3031	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3032		std::fmt::Display::fmt(self.syntax(), f)3033	}3034}3035impl std::fmt::Display for ObjLocal {3036	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3037		std::fmt::Display::fmt(self.syntax(), f)3038	}3039}3040impl std::fmt::Display for MemberAssertStmt {3041	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3042		std::fmt::Display::fmt(self.syntax(), f)3043	}3044}3045impl std::fmt::Display for MemberFieldNormal {3046	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3047		std::fmt::Display::fmt(self.syntax(), f)3048	}3049}3050impl std::fmt::Display for Visibility {3051	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3052		std::fmt::Display::fmt(self.syntax(), f)3053	}3054}3055impl std::fmt::Display for MemberFieldMethod {3056	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3057		std::fmt::Display::fmt(self.syntax(), f)3058	}3059}3060impl std::fmt::Display for FieldNameFixed {3061	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3062		std::fmt::Display::fmt(self.syntax(), f)3063	}3064}3065impl std::fmt::Display for FieldNameDynamic {3066	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3067		std::fmt::Display::fmt(self.syntax(), f)3068	}3069}3070impl std::fmt::Display for ForSpec {3071	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3072		std::fmt::Display::fmt(self.syntax(), f)3073	}3074}3075impl std::fmt::Display for ForObjSpec {3076	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3077		std::fmt::Display::fmt(self.syntax(), f)3078	}3079}3080impl std::fmt::Display for IfSpec {3081	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3082		std::fmt::Display::fmt(self.syntax(), f)3083	}3084}3085impl std::fmt::Display for BindDestruct {3086	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3087		std::fmt::Display::fmt(self.syntax(), f)3088	}3089}3090impl std::fmt::Display for BindFunction {3091	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3092		std::fmt::Display::fmt(self.syntax(), f)3093	}3094}3095impl std::fmt::Display for Param {3096	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3097		std::fmt::Display::fmt(self.syntax(), f)3098	}3099}3100impl std::fmt::Display for DestructFull {3101	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3102		std::fmt::Display::fmt(self.syntax(), f)3103	}3104}3105impl std::fmt::Display for DestructSkip {3106	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3107		std::fmt::Display::fmt(self.syntax(), f)3108	}3109}3110impl std::fmt::Display for DestructArray {3111	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3112		std::fmt::Display::fmt(self.syntax(), f)3113	}3114}3115impl std::fmt::Display for DestructObject {3116	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3117		std::fmt::Display::fmt(self.syntax(), f)3118	}3119}3120impl std::fmt::Display for DestructObjectField {3121	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3122		std::fmt::Display::fmt(self.syntax(), f)3123	}3124}3125impl std::fmt::Display for DestructRest {3126	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3127		std::fmt::Display::fmt(self.syntax(), f)3128	}3129}3130impl std::fmt::Display for DestructArrayElement {3131	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3132		std::fmt::Display::fmt(self.syntax(), f)3133	}3134}