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

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}981982#[derive(Debug, Clone, PartialEq, Eq, Hash)]983pub struct Literal {984	syntax: SyntaxToken,985	kind: LiteralKind,986}987988#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]989pub enum LiteralKind {990	NullKw,991	TrueKw,992	FalseKw,993	SelfKw,994	Dollar,995	SuperKw,996}997998#[derive(Debug, Clone, PartialEq, Eq, Hash)]999pub struct Text {1000	syntax: SyntaxToken,1001	kind: TextKind,1002}10031004#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]1005pub enum TextKind {1006	StringDouble,1007	ErrorStringDoubleUnterminated,1008	StringSingle,1009	ErrorStringSingleUnterminated,1010	StringDoubleVerbatim,1011	ErrorStringDoubleVerbatimUnterminated,1012	StringSingleVerbatim,1013	ErrorStringSingleVerbatimUnterminated,1014	ErrorStringVerbatimMissingQuotes,1015	StringBlock,1016	ErrorStringBlockUnexpectedEnd,1017	ErrorStringBlockMissingNewLine,1018	ErrorStringBlockMissingTermination,1019	ErrorStringBlockMissingIndent,1020}10211022#[derive(Debug, Clone, PartialEq, Eq, Hash)]1023pub struct Number {1024	syntax: SyntaxToken,1025	kind: NumberKind,1026}10271028#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]1029pub enum NumberKind {1030	Float,1031	ErrorFloatJunkAfterPoint,1032	ErrorFloatJunkAfterExponent,1033	ErrorFloatJunkAfterExponentSign,1034}10351036#[derive(Debug, Clone, PartialEq, Eq, Hash)]1037pub struct ImportKind {1038	syntax: SyntaxToken,1039	kind: ImportKindKind,1040}10411042#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]1043pub enum ImportKindKind {1044	ImportstrKw,1045	ImportbinKw,1046	ImportKw,1047}10481049#[derive(Debug, Clone, PartialEq, Eq, Hash)]1050pub struct Trivia {1051	syntax: SyntaxToken,1052	kind: TriviaKind,1053}10541055#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]1056pub enum TriviaKind {1057	Whitespace,1058	MultiLineComment,1059	ErrorCommentTooShort,1060	ErrorCommentUnterminated,1061	SingleLineHashComment,1062	SingleLineSlashComment,1063}10641065#[derive(Debug, Clone, PartialEq, Eq, Hash)]1066pub struct CustomError {1067	syntax: SyntaxToken,1068	kind: CustomErrorKind,1069}10701071#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]1072pub enum CustomErrorKind {1073	ErrorMissingToken,1074	ErrorUnexpectedToken,1075	ErrorCustom,1076}1077impl AstNode for SourceFile {1078	fn can_cast(kind: SyntaxKind) -> bool {1079		kind == SOURCE_FILE1080	}1081	fn cast(syntax: SyntaxNode) -> Option<Self> {1082		if Self::can_cast(syntax.kind()) {1083			Some(Self { syntax })1084		} else {1085			None1086		}1087	}1088	fn syntax(&self) -> &SyntaxNode {1089		&self.syntax1090	}1091}1092impl AstNode for Expr {1093	fn can_cast(kind: SyntaxKind) -> bool {1094		kind == EXPR1095	}1096	fn cast(syntax: SyntaxNode) -> Option<Self> {1097		if Self::can_cast(syntax.kind()) {1098			Some(Self { syntax })1099		} else {1100			None1101		}1102	}1103	fn syntax(&self) -> &SyntaxNode {1104		&self.syntax1105	}1106}1107impl AstNode for SuffixIndex {1108	fn can_cast(kind: SyntaxKind) -> bool {1109		kind == SUFFIX_INDEX1110	}1111	fn cast(syntax: SyntaxNode) -> Option<Self> {1112		if Self::can_cast(syntax.kind()) {1113			Some(Self { syntax })1114		} else {1115			None1116		}1117	}1118	fn syntax(&self) -> &SyntaxNode {1119		&self.syntax1120	}1121}1122impl AstNode for Name {1123	fn can_cast(kind: SyntaxKind) -> bool {1124		kind == NAME1125	}1126	fn cast(syntax: SyntaxNode) -> Option<Self> {1127		if Self::can_cast(syntax.kind()) {1128			Some(Self { syntax })1129		} else {1130			None1131		}1132	}1133	fn syntax(&self) -> &SyntaxNode {1134		&self.syntax1135	}1136}1137impl AstNode for SuffixIndexExpr {1138	fn can_cast(kind: SyntaxKind) -> bool {1139		kind == SUFFIX_INDEX_EXPR1140	}1141	fn cast(syntax: SyntaxNode) -> Option<Self> {1142		if Self::can_cast(syntax.kind()) {1143			Some(Self { syntax })1144		} else {1145			None1146		}1147	}1148	fn syntax(&self) -> &SyntaxNode {1149		&self.syntax1150	}1151}1152impl AstNode for SuffixSlice {1153	fn can_cast(kind: SyntaxKind) -> bool {1154		kind == SUFFIX_SLICE1155	}1156	fn cast(syntax: SyntaxNode) -> Option<Self> {1157		if Self::can_cast(syntax.kind()) {1158			Some(Self { syntax })1159		} else {1160			None1161		}1162	}1163	fn syntax(&self) -> &SyntaxNode {1164		&self.syntax1165	}1166}1167impl AstNode for SliceDesc {1168	fn can_cast(kind: SyntaxKind) -> bool {1169		kind == SLICE_DESC1170	}1171	fn cast(syntax: SyntaxNode) -> Option<Self> {1172		if Self::can_cast(syntax.kind()) {1173			Some(Self { syntax })1174		} else {1175			None1176		}1177	}1178	fn syntax(&self) -> &SyntaxNode {1179		&self.syntax1180	}1181}1182impl AstNode for SuffixApply {1183	fn can_cast(kind: SyntaxKind) -> bool {1184		kind == SUFFIX_APPLY1185	}1186	fn cast(syntax: SyntaxNode) -> Option<Self> {1187		if Self::can_cast(syntax.kind()) {1188			Some(Self { syntax })1189		} else {1190			None1191		}1192	}1193	fn syntax(&self) -> &SyntaxNode {1194		&self.syntax1195	}1196}1197impl AstNode for ArgsDesc {1198	fn can_cast(kind: SyntaxKind) -> bool {1199		kind == ARGS_DESC1200	}1201	fn cast(syntax: SyntaxNode) -> Option<Self> {1202		if Self::can_cast(syntax.kind()) {1203			Some(Self { syntax })1204		} else {1205			None1206		}1207	}1208	fn syntax(&self) -> &SyntaxNode {1209		&self.syntax1210	}1211}1212impl AstNode for StmtLocal {1213	fn can_cast(kind: SyntaxKind) -> bool {1214		kind == STMT_LOCAL1215	}1216	fn cast(syntax: SyntaxNode) -> Option<Self> {1217		if Self::can_cast(syntax.kind()) {1218			Some(Self { syntax })1219		} else {1220			None1221		}1222	}1223	fn syntax(&self) -> &SyntaxNode {1224		&self.syntax1225	}1226}1227impl AstNode for StmtAssert {1228	fn can_cast(kind: SyntaxKind) -> bool {1229		kind == STMT_ASSERT1230	}1231	fn cast(syntax: SyntaxNode) -> Option<Self> {1232		if Self::can_cast(syntax.kind()) {1233			Some(Self { syntax })1234		} else {1235			None1236		}1237	}1238	fn syntax(&self) -> &SyntaxNode {1239		&self.syntax1240	}1241}1242impl AstNode for Assertion {1243	fn can_cast(kind: SyntaxKind) -> bool {1244		kind == ASSERTION1245	}1246	fn cast(syntax: SyntaxNode) -> Option<Self> {1247		if Self::can_cast(syntax.kind()) {1248			Some(Self { syntax })1249		} else {1250			None1251		}1252	}1253	fn syntax(&self) -> &SyntaxNode {1254		&self.syntax1255	}1256}1257impl AstNode for ExprBinary {1258	fn can_cast(kind: SyntaxKind) -> bool {1259		kind == EXPR_BINARY1260	}1261	fn cast(syntax: SyntaxNode) -> Option<Self> {1262		if Self::can_cast(syntax.kind()) {1263			Some(Self { syntax })1264		} else {1265			None1266		}1267	}1268	fn syntax(&self) -> &SyntaxNode {1269		&self.syntax1270	}1271}1272impl AstNode for ExprUnary {1273	fn can_cast(kind: SyntaxKind) -> bool {1274		kind == EXPR_UNARY1275	}1276	fn cast(syntax: SyntaxNode) -> Option<Self> {1277		if Self::can_cast(syntax.kind()) {1278			Some(Self { syntax })1279		} else {1280			None1281		}1282	}1283	fn syntax(&self) -> &SyntaxNode {1284		&self.syntax1285	}1286}1287impl AstNode for ExprObjExtend {1288	fn can_cast(kind: SyntaxKind) -> bool {1289		kind == EXPR_OBJ_EXTEND1290	}1291	fn cast(syntax: SyntaxNode) -> Option<Self> {1292		if Self::can_cast(syntax.kind()) {1293			Some(Self { syntax })1294		} else {1295			None1296		}1297	}1298	fn syntax(&self) -> &SyntaxNode {1299		&self.syntax1300	}1301}1302impl AstNode for ExprParened {1303	fn can_cast(kind: SyntaxKind) -> bool {1304		kind == EXPR_PARENED1305	}1306	fn cast(syntax: SyntaxNode) -> Option<Self> {1307		if Self::can_cast(syntax.kind()) {1308			Some(Self { syntax })1309		} else {1310			None1311		}1312	}1313	fn syntax(&self) -> &SyntaxNode {1314		&self.syntax1315	}1316}1317impl AstNode for ExprLiteral {1318	fn can_cast(kind: SyntaxKind) -> bool {1319		kind == EXPR_LITERAL1320	}1321	fn cast(syntax: SyntaxNode) -> Option<Self> {1322		if Self::can_cast(syntax.kind()) {1323			Some(Self { syntax })1324		} else {1325			None1326		}1327	}1328	fn syntax(&self) -> &SyntaxNode {1329		&self.syntax1330	}1331}1332impl AstNode for ExprString {1333	fn can_cast(kind: SyntaxKind) -> bool {1334		kind == EXPR_STRING1335	}1336	fn cast(syntax: SyntaxNode) -> Option<Self> {1337		if Self::can_cast(syntax.kind()) {1338			Some(Self { syntax })1339		} else {1340			None1341		}1342	}1343	fn syntax(&self) -> &SyntaxNode {1344		&self.syntax1345	}1346}1347impl AstNode for ExprNumber {1348	fn can_cast(kind: SyntaxKind) -> bool {1349		kind == EXPR_NUMBER1350	}1351	fn cast(syntax: SyntaxNode) -> Option<Self> {1352		if Self::can_cast(syntax.kind()) {1353			Some(Self { syntax })1354		} else {1355			None1356		}1357	}1358	fn syntax(&self) -> &SyntaxNode {1359		&self.syntax1360	}1361}1362impl AstNode for ExprArray {1363	fn can_cast(kind: SyntaxKind) -> bool {1364		kind == EXPR_ARRAY1365	}1366	fn cast(syntax: SyntaxNode) -> Option<Self> {1367		if Self::can_cast(syntax.kind()) {1368			Some(Self { syntax })1369		} else {1370			None1371		}1372	}1373	fn syntax(&self) -> &SyntaxNode {1374		&self.syntax1375	}1376}1377impl AstNode for ExprObject {1378	fn can_cast(kind: SyntaxKind) -> bool {1379		kind == EXPR_OBJECT1380	}1381	fn cast(syntax: SyntaxNode) -> Option<Self> {1382		if Self::can_cast(syntax.kind()) {1383			Some(Self { syntax })1384		} else {1385			None1386		}1387	}1388	fn syntax(&self) -> &SyntaxNode {1389		&self.syntax1390	}1391}1392impl AstNode for ExprArrayComp {1393	fn can_cast(kind: SyntaxKind) -> bool {1394		kind == EXPR_ARRAY_COMP1395	}1396	fn cast(syntax: SyntaxNode) -> Option<Self> {1397		if Self::can_cast(syntax.kind()) {1398			Some(Self { syntax })1399		} else {1400			None1401		}1402	}1403	fn syntax(&self) -> &SyntaxNode {1404		&self.syntax1405	}1406}1407impl AstNode for ExprImport {1408	fn can_cast(kind: SyntaxKind) -> bool {1409		kind == EXPR_IMPORT1410	}1411	fn cast(syntax: SyntaxNode) -> Option<Self> {1412		if Self::can_cast(syntax.kind()) {1413			Some(Self { syntax })1414		} else {1415			None1416		}1417	}1418	fn syntax(&self) -> &SyntaxNode {1419		&self.syntax1420	}1421}1422impl AstNode for ExprVar {1423	fn can_cast(kind: SyntaxKind) -> bool {1424		kind == EXPR_VAR1425	}1426	fn cast(syntax: SyntaxNode) -> Option<Self> {1427		if Self::can_cast(syntax.kind()) {1428			Some(Self { syntax })1429		} else {1430			None1431		}1432	}1433	fn syntax(&self) -> &SyntaxNode {1434		&self.syntax1435	}1436}1437impl AstNode for ExprIfThenElse {1438	fn can_cast(kind: SyntaxKind) -> bool {1439		kind == EXPR_IF_THEN_ELSE1440	}1441	fn cast(syntax: SyntaxNode) -> Option<Self> {1442		if Self::can_cast(syntax.kind()) {1443			Some(Self { syntax })1444		} else {1445			None1446		}1447	}1448	fn syntax(&self) -> &SyntaxNode {1449		&self.syntax1450	}1451}1452impl AstNode for TrueExpr {1453	fn can_cast(kind: SyntaxKind) -> bool {1454		kind == TRUE_EXPR1455	}1456	fn cast(syntax: SyntaxNode) -> Option<Self> {1457		if Self::can_cast(syntax.kind()) {1458			Some(Self { syntax })1459		} else {1460			None1461		}1462	}1463	fn syntax(&self) -> &SyntaxNode {1464		&self.syntax1465	}1466}1467impl AstNode for FalseExpr {1468	fn can_cast(kind: SyntaxKind) -> bool {1469		kind == FALSE_EXPR1470	}1471	fn cast(syntax: SyntaxNode) -> Option<Self> {1472		if Self::can_cast(syntax.kind()) {1473			Some(Self { syntax })1474		} else {1475			None1476		}1477	}1478	fn syntax(&self) -> &SyntaxNode {1479		&self.syntax1480	}1481}1482impl AstNode for ExprFunction {1483	fn can_cast(kind: SyntaxKind) -> bool {1484		kind == EXPR_FUNCTION1485	}1486	fn cast(syntax: SyntaxNode) -> Option<Self> {1487		if Self::can_cast(syntax.kind()) {1488			Some(Self { syntax })1489		} else {1490			None1491		}1492	}1493	fn syntax(&self) -> &SyntaxNode {1494		&self.syntax1495	}1496}1497impl AstNode for ParamsDesc {1498	fn can_cast(kind: SyntaxKind) -> bool {1499		kind == PARAMS_DESC1500	}1501	fn cast(syntax: SyntaxNode) -> Option<Self> {1502		if Self::can_cast(syntax.kind()) {1503			Some(Self { syntax })1504		} else {1505			None1506		}1507	}1508	fn syntax(&self) -> &SyntaxNode {1509		&self.syntax1510	}1511}1512impl AstNode for ExprError {1513	fn can_cast(kind: SyntaxKind) -> bool {1514		kind == EXPR_ERROR1515	}1516	fn cast(syntax: SyntaxNode) -> Option<Self> {1517		if Self::can_cast(syntax.kind()) {1518			Some(Self { syntax })1519		} else {1520			None1521		}1522	}1523	fn syntax(&self) -> &SyntaxNode {1524		&self.syntax1525	}1526}1527impl AstNode for SliceDescEnd {1528	fn can_cast(kind: SyntaxKind) -> bool {1529		kind == SLICE_DESC_END1530	}1531	fn cast(syntax: SyntaxNode) -> Option<Self> {1532		if Self::can_cast(syntax.kind()) {1533			Some(Self { syntax })1534		} else {1535			None1536		}1537	}1538	fn syntax(&self) -> &SyntaxNode {1539		&self.syntax1540	}1541}1542impl AstNode for SliceDescStep {1543	fn can_cast(kind: SyntaxKind) -> bool {1544		kind == SLICE_DESC_STEP1545	}1546	fn cast(syntax: SyntaxNode) -> Option<Self> {1547		if Self::can_cast(syntax.kind()) {1548			Some(Self { syntax })1549		} else {1550			None1551		}1552	}1553	fn syntax(&self) -> &SyntaxNode {1554		&self.syntax1555	}1556}1557impl AstNode for Arg {1558	fn can_cast(kind: SyntaxKind) -> bool {1559		kind == ARG1560	}1561	fn cast(syntax: SyntaxNode) -> Option<Self> {1562		if Self::can_cast(syntax.kind()) {1563			Some(Self { syntax })1564		} else {1565			None1566		}1567	}1568	fn syntax(&self) -> &SyntaxNode {1569		&self.syntax1570	}1571}1572impl AstNode for ObjBodyComp {1573	fn can_cast(kind: SyntaxKind) -> bool {1574		kind == OBJ_BODY_COMP1575	}1576	fn cast(syntax: SyntaxNode) -> Option<Self> {1577		if Self::can_cast(syntax.kind()) {1578			Some(Self { syntax })1579		} else {1580			None1581		}1582	}1583	fn syntax(&self) -> &SyntaxNode {1584		&self.syntax1585	}1586}1587impl AstNode for ObjBodyMemberList {1588	fn can_cast(kind: SyntaxKind) -> bool {1589		kind == OBJ_BODY_MEMBER_LIST1590	}1591	fn cast(syntax: SyntaxNode) -> Option<Self> {1592		if Self::can_cast(syntax.kind()) {1593			Some(Self { syntax })1594		} else {1595			None1596		}1597	}1598	fn syntax(&self) -> &SyntaxNode {1599		&self.syntax1600	}1601}1602impl AstNode for MemberBindStmt {1603	fn can_cast(kind: SyntaxKind) -> bool {1604		kind == MEMBER_BIND_STMT1605	}1606	fn cast(syntax: SyntaxNode) -> Option<Self> {1607		if Self::can_cast(syntax.kind()) {1608			Some(Self { syntax })1609		} else {1610			None1611		}1612	}1613	fn syntax(&self) -> &SyntaxNode {1614		&self.syntax1615	}1616}1617impl AstNode for ObjLocal {1618	fn can_cast(kind: SyntaxKind) -> bool {1619		kind == OBJ_LOCAL1620	}1621	fn cast(syntax: SyntaxNode) -> Option<Self> {1622		if Self::can_cast(syntax.kind()) {1623			Some(Self { syntax })1624		} else {1625			None1626		}1627	}1628	fn syntax(&self) -> &SyntaxNode {1629		&self.syntax1630	}1631}1632impl AstNode for MemberAssertStmt {1633	fn can_cast(kind: SyntaxKind) -> bool {1634		kind == MEMBER_ASSERT_STMT1635	}1636	fn cast(syntax: SyntaxNode) -> Option<Self> {1637		if Self::can_cast(syntax.kind()) {1638			Some(Self { syntax })1639		} else {1640			None1641		}1642	}1643	fn syntax(&self) -> &SyntaxNode {1644		&self.syntax1645	}1646}1647impl AstNode for MemberFieldNormal {1648	fn can_cast(kind: SyntaxKind) -> bool {1649		kind == MEMBER_FIELD_NORMAL1650	}1651	fn cast(syntax: SyntaxNode) -> Option<Self> {1652		if Self::can_cast(syntax.kind()) {1653			Some(Self { syntax })1654		} else {1655			None1656		}1657	}1658	fn syntax(&self) -> &SyntaxNode {1659		&self.syntax1660	}1661}1662impl AstNode for Visibility {1663	fn can_cast(kind: SyntaxKind) -> bool {1664		kind == VISIBILITY1665	}1666	fn cast(syntax: SyntaxNode) -> Option<Self> {1667		if Self::can_cast(syntax.kind()) {1668			Some(Self { syntax })1669		} else {1670			None1671		}1672	}1673	fn syntax(&self) -> &SyntaxNode {1674		&self.syntax1675	}1676}1677impl AstNode for MemberFieldMethod {1678	fn can_cast(kind: SyntaxKind) -> bool {1679		kind == MEMBER_FIELD_METHOD1680	}1681	fn cast(syntax: SyntaxNode) -> Option<Self> {1682		if Self::can_cast(syntax.kind()) {1683			Some(Self { syntax })1684		} else {1685			None1686		}1687	}1688	fn syntax(&self) -> &SyntaxNode {1689		&self.syntax1690	}1691}1692impl AstNode for FieldNameFixed {1693	fn can_cast(kind: SyntaxKind) -> bool {1694		kind == FIELD_NAME_FIXED1695	}1696	fn cast(syntax: SyntaxNode) -> Option<Self> {1697		if Self::can_cast(syntax.kind()) {1698			Some(Self { syntax })1699		} else {1700			None1701		}1702	}1703	fn syntax(&self) -> &SyntaxNode {1704		&self.syntax1705	}1706}1707impl AstNode for FieldNameDynamic {1708	fn can_cast(kind: SyntaxKind) -> bool {1709		kind == FIELD_NAME_DYNAMIC1710	}1711	fn cast(syntax: SyntaxNode) -> Option<Self> {1712		if Self::can_cast(syntax.kind()) {1713			Some(Self { syntax })1714		} else {1715			None1716		}1717	}1718	fn syntax(&self) -> &SyntaxNode {1719		&self.syntax1720	}1721}1722impl AstNode for ForSpec {1723	fn can_cast(kind: SyntaxKind) -> bool {1724		kind == FOR_SPEC1725	}1726	fn cast(syntax: SyntaxNode) -> Option<Self> {1727		if Self::can_cast(syntax.kind()) {1728			Some(Self { syntax })1729		} else {1730			None1731		}1732	}1733	fn syntax(&self) -> &SyntaxNode {1734		&self.syntax1735	}1736}1737impl AstNode for ForObjSpec {1738	fn can_cast(kind: SyntaxKind) -> bool {1739		kind == FOR_OBJ_SPEC1740	}1741	fn cast(syntax: SyntaxNode) -> Option<Self> {1742		if Self::can_cast(syntax.kind()) {1743			Some(Self { syntax })1744		} else {1745			None1746		}1747	}1748	fn syntax(&self) -> &SyntaxNode {1749		&self.syntax1750	}1751}1752impl AstNode for IfSpec {1753	fn can_cast(kind: SyntaxKind) -> bool {1754		kind == IF_SPEC1755	}1756	fn cast(syntax: SyntaxNode) -> Option<Self> {1757		if Self::can_cast(syntax.kind()) {1758			Some(Self { syntax })1759		} else {1760			None1761		}1762	}1763	fn syntax(&self) -> &SyntaxNode {1764		&self.syntax1765	}1766}1767impl AstNode for BindDestruct {1768	fn can_cast(kind: SyntaxKind) -> bool {1769		kind == BIND_DESTRUCT1770	}1771	fn cast(syntax: SyntaxNode) -> Option<Self> {1772		if Self::can_cast(syntax.kind()) {1773			Some(Self { syntax })1774		} else {1775			None1776		}1777	}1778	fn syntax(&self) -> &SyntaxNode {1779		&self.syntax1780	}1781}1782impl AstNode for BindFunction {1783	fn can_cast(kind: SyntaxKind) -> bool {1784		kind == BIND_FUNCTION1785	}1786	fn cast(syntax: SyntaxNode) -> Option<Self> {1787		if Self::can_cast(syntax.kind()) {1788			Some(Self { syntax })1789		} else {1790			None1791		}1792	}1793	fn syntax(&self) -> &SyntaxNode {1794		&self.syntax1795	}1796}1797impl AstNode for Param {1798	fn can_cast(kind: SyntaxKind) -> bool {1799		kind == PARAM1800	}1801	fn cast(syntax: SyntaxNode) -> Option<Self> {1802		if Self::can_cast(syntax.kind()) {1803			Some(Self { syntax })1804		} else {1805			None1806		}1807	}1808	fn syntax(&self) -> &SyntaxNode {1809		&self.syntax1810	}1811}1812impl AstNode for DestructFull {1813	fn can_cast(kind: SyntaxKind) -> bool {1814		kind == DESTRUCT_FULL1815	}1816	fn cast(syntax: SyntaxNode) -> Option<Self> {1817		if Self::can_cast(syntax.kind()) {1818			Some(Self { syntax })1819		} else {1820			None1821		}1822	}1823	fn syntax(&self) -> &SyntaxNode {1824		&self.syntax1825	}1826}1827impl AstNode for DestructSkip {1828	fn can_cast(kind: SyntaxKind) -> bool {1829		kind == DESTRUCT_SKIP1830	}1831	fn cast(syntax: SyntaxNode) -> Option<Self> {1832		if Self::can_cast(syntax.kind()) {1833			Some(Self { syntax })1834		} else {1835			None1836		}1837	}1838	fn syntax(&self) -> &SyntaxNode {1839		&self.syntax1840	}1841}1842impl AstNode for DestructArray {1843	fn can_cast(kind: SyntaxKind) -> bool {1844		kind == DESTRUCT_ARRAY1845	}1846	fn cast(syntax: SyntaxNode) -> Option<Self> {1847		if Self::can_cast(syntax.kind()) {1848			Some(Self { syntax })1849		} else {1850			None1851		}1852	}1853	fn syntax(&self) -> &SyntaxNode {1854		&self.syntax1855	}1856}1857impl AstNode for DestructObject {1858	fn can_cast(kind: SyntaxKind) -> bool {1859		kind == DESTRUCT_OBJECT1860	}1861	fn cast(syntax: SyntaxNode) -> Option<Self> {1862		if Self::can_cast(syntax.kind()) {1863			Some(Self { syntax })1864		} else {1865			None1866		}1867	}1868	fn syntax(&self) -> &SyntaxNode {1869		&self.syntax1870	}1871}1872impl AstNode for DestructObjectField {1873	fn can_cast(kind: SyntaxKind) -> bool {1874		kind == DESTRUCT_OBJECT_FIELD1875	}1876	fn cast(syntax: SyntaxNode) -> Option<Self> {1877		if Self::can_cast(syntax.kind()) {1878			Some(Self { syntax })1879		} else {1880			None1881		}1882	}1883	fn syntax(&self) -> &SyntaxNode {1884		&self.syntax1885	}1886}1887impl AstNode for DestructRest {1888	fn can_cast(kind: SyntaxKind) -> bool {1889		kind == DESTRUCT_REST1890	}1891	fn cast(syntax: SyntaxNode) -> Option<Self> {1892		if Self::can_cast(syntax.kind()) {1893			Some(Self { syntax })1894		} else {1895			None1896		}1897	}1898	fn syntax(&self) -> &SyntaxNode {1899		&self.syntax1900	}1901}1902impl AstNode for DestructArrayElement {1903	fn can_cast(kind: SyntaxKind) -> bool {1904		kind == DESTRUCT_ARRAY_ELEMENT1905	}1906	fn cast(syntax: SyntaxNode) -> Option<Self> {1907		if Self::can_cast(syntax.kind()) {1908			Some(Self { syntax })1909		} else {1910			None1911		}1912	}1913	fn syntax(&self) -> &SyntaxNode {1914		&self.syntax1915	}1916}1917impl From<SuffixIndex> for Suffix {1918	fn from(node: SuffixIndex) -> Suffix {1919		Suffix::SuffixIndex(node)1920	}1921}1922impl From<SuffixIndexExpr> for Suffix {1923	fn from(node: SuffixIndexExpr) -> Suffix {1924		Suffix::SuffixIndexExpr(node)1925	}1926}1927impl From<SuffixSlice> for Suffix {1928	fn from(node: SuffixSlice) -> Suffix {1929		Suffix::SuffixSlice(node)1930	}1931}1932impl From<SuffixApply> for Suffix {1933	fn from(node: SuffixApply) -> Suffix {1934		Suffix::SuffixApply(node)1935	}1936}1937impl AstNode for Suffix {1938	fn can_cast(kind: SyntaxKind) -> bool {1939		match kind {1940			SUFFIX_INDEX | SUFFIX_INDEX_EXPR | SUFFIX_SLICE | SUFFIX_APPLY => true,1941			_ => false,1942		}1943	}1944	fn cast(syntax: SyntaxNode) -> Option<Self> {1945		let res = match syntax.kind() {1946			SUFFIX_INDEX => Suffix::SuffixIndex(SuffixIndex { syntax }),1947			SUFFIX_INDEX_EXPR => Suffix::SuffixIndexExpr(SuffixIndexExpr { syntax }),1948			SUFFIX_SLICE => Suffix::SuffixSlice(SuffixSlice { syntax }),1949			SUFFIX_APPLY => Suffix::SuffixApply(SuffixApply { syntax }),1950			_ => return None,1951		};1952		Some(res)1953	}1954	fn syntax(&self) -> &SyntaxNode {1955		match self {1956			Suffix::SuffixIndex(it) => &it.syntax,1957			Suffix::SuffixIndexExpr(it) => &it.syntax,1958			Suffix::SuffixSlice(it) => &it.syntax,1959			Suffix::SuffixApply(it) => &it.syntax,1960		}1961	}1962}1963impl From<BindDestruct> for Bind {1964	fn from(node: BindDestruct) -> Bind {1965		Bind::BindDestruct(node)1966	}1967}1968impl From<BindFunction> for Bind {1969	fn from(node: BindFunction) -> Bind {1970		Bind::BindFunction(node)1971	}1972}1973impl AstNode for Bind {1974	fn can_cast(kind: SyntaxKind) -> bool {1975		match kind {1976			BIND_DESTRUCT | BIND_FUNCTION => true,1977			_ => false,1978		}1979	}1980	fn cast(syntax: SyntaxNode) -> Option<Self> {1981		let res = match syntax.kind() {1982			BIND_DESTRUCT => Bind::BindDestruct(BindDestruct { syntax }),1983			BIND_FUNCTION => Bind::BindFunction(BindFunction { syntax }),1984			_ => return None,1985		};1986		Some(res)1987	}1988	fn syntax(&self) -> &SyntaxNode {1989		match self {1990			Bind::BindDestruct(it) => &it.syntax,1991			Bind::BindFunction(it) => &it.syntax,1992		}1993	}1994}1995impl From<StmtLocal> for Stmt {1996	fn from(node: StmtLocal) -> Stmt {1997		Stmt::StmtLocal(node)1998	}1999}2000impl From<StmtAssert> for Stmt {2001	fn from(node: StmtAssert) -> Stmt {2002		Stmt::StmtAssert(node)2003	}2004}2005impl AstNode for Stmt {2006	fn can_cast(kind: SyntaxKind) -> bool {2007		match kind {2008			STMT_LOCAL | STMT_ASSERT => true,2009			_ => false,2010		}2011	}2012	fn cast(syntax: SyntaxNode) -> Option<Self> {2013		let res = match syntax.kind() {2014			STMT_LOCAL => Stmt::StmtLocal(StmtLocal { syntax }),2015			STMT_ASSERT => Stmt::StmtAssert(StmtAssert { syntax }),2016			_ => return None,2017		};2018		Some(res)2019	}2020	fn syntax(&self) -> &SyntaxNode {2021		match self {2022			Stmt::StmtLocal(it) => &it.syntax,2023			Stmt::StmtAssert(it) => &it.syntax,2024		}2025	}2026}2027impl From<ObjBodyComp> for ObjBody {2028	fn from(node: ObjBodyComp) -> ObjBody {2029		ObjBody::ObjBodyComp(node)2030	}2031}2032impl From<ObjBodyMemberList> for ObjBody {2033	fn from(node: ObjBodyMemberList) -> ObjBody {2034		ObjBody::ObjBodyMemberList(node)2035	}2036}2037impl AstNode for ObjBody {2038	fn can_cast(kind: SyntaxKind) -> bool {2039		match kind {2040			OBJ_BODY_COMP | OBJ_BODY_MEMBER_LIST => true,2041			_ => false,2042		}2043	}2044	fn cast(syntax: SyntaxNode) -> Option<Self> {2045		let res = match syntax.kind() {2046			OBJ_BODY_COMP => ObjBody::ObjBodyComp(ObjBodyComp { syntax }),2047			OBJ_BODY_MEMBER_LIST => ObjBody::ObjBodyMemberList(ObjBodyMemberList { syntax }),2048			_ => return None,2049		};2050		Some(res)2051	}2052	fn syntax(&self) -> &SyntaxNode {2053		match self {2054			ObjBody::ObjBodyComp(it) => &it.syntax,2055			ObjBody::ObjBodyMemberList(it) => &it.syntax,2056		}2057	}2058}2059impl From<ForSpec> for CompSpec {2060	fn from(node: ForSpec) -> CompSpec {2061		CompSpec::ForSpec(node)2062	}2063}2064impl From<ForObjSpec> for CompSpec {2065	fn from(node: ForObjSpec) -> CompSpec {2066		CompSpec::ForObjSpec(node)2067	}2068}2069impl From<IfSpec> for CompSpec {2070	fn from(node: IfSpec) -> CompSpec {2071		CompSpec::IfSpec(node)2072	}2073}2074impl AstNode for CompSpec {2075	fn can_cast(kind: SyntaxKind) -> bool {2076		match kind {2077			FOR_SPEC | FOR_OBJ_SPEC | IF_SPEC => true,2078			_ => false,2079		}2080	}2081	fn cast(syntax: SyntaxNode) -> Option<Self> {2082		let res = match syntax.kind() {2083			FOR_SPEC => CompSpec::ForSpec(ForSpec { syntax }),2084			FOR_OBJ_SPEC => CompSpec::ForObjSpec(ForObjSpec { syntax }),2085			IF_SPEC => CompSpec::IfSpec(IfSpec { syntax }),2086			_ => return None,2087		};2088		Some(res)2089	}2090	fn syntax(&self) -> &SyntaxNode {2091		match self {2092			CompSpec::ForSpec(it) => &it.syntax,2093			CompSpec::ForObjSpec(it) => &it.syntax,2094			CompSpec::IfSpec(it) => &it.syntax,2095		}2096	}2097}2098impl From<ExprBinary> for ExprBase {2099	fn from(node: ExprBinary) -> ExprBase {2100		ExprBase::ExprBinary(node)2101	}2102}2103impl From<ExprUnary> for ExprBase {2104	fn from(node: ExprUnary) -> ExprBase {2105		ExprBase::ExprUnary(node)2106	}2107}2108impl From<ExprObjExtend> for ExprBase {2109	fn from(node: ExprObjExtend) -> ExprBase {2110		ExprBase::ExprObjExtend(node)2111	}2112}2113impl From<ExprParened> for ExprBase {2114	fn from(node: ExprParened) -> ExprBase {2115		ExprBase::ExprParened(node)2116	}2117}2118impl From<ExprString> for ExprBase {2119	fn from(node: ExprString) -> ExprBase {2120		ExprBase::ExprString(node)2121	}2122}2123impl From<ExprNumber> for ExprBase {2124	fn from(node: ExprNumber) -> ExprBase {2125		ExprBase::ExprNumber(node)2126	}2127}2128impl From<ExprLiteral> for ExprBase {2129	fn from(node: ExprLiteral) -> ExprBase {2130		ExprBase::ExprLiteral(node)2131	}2132}2133impl From<ExprArray> for ExprBase {2134	fn from(node: ExprArray) -> ExprBase {2135		ExprBase::ExprArray(node)2136	}2137}2138impl From<ExprObject> for ExprBase {2139	fn from(node: ExprObject) -> ExprBase {2140		ExprBase::ExprObject(node)2141	}2142}2143impl From<ExprArrayComp> for ExprBase {2144	fn from(node: ExprArrayComp) -> ExprBase {2145		ExprBase::ExprArrayComp(node)2146	}2147}2148impl From<ExprImport> for ExprBase {2149	fn from(node: ExprImport) -> ExprBase {2150		ExprBase::ExprImport(node)2151	}2152}2153impl From<ExprVar> for ExprBase {2154	fn from(node: ExprVar) -> ExprBase {2155		ExprBase::ExprVar(node)2156	}2157}2158impl From<ExprIfThenElse> for ExprBase {2159	fn from(node: ExprIfThenElse) -> ExprBase {2160		ExprBase::ExprIfThenElse(node)2161	}2162}2163impl From<ExprFunction> for ExprBase {2164	fn from(node: ExprFunction) -> ExprBase {2165		ExprBase::ExprFunction(node)2166	}2167}2168impl From<ExprError> for ExprBase {2169	fn from(node: ExprError) -> ExprBase {2170		ExprBase::ExprError(node)2171	}2172}2173impl AstNode for ExprBase {2174	fn can_cast(kind: SyntaxKind) -> bool {2175		match kind {2176			EXPR_BINARY | EXPR_UNARY | EXPR_OBJ_EXTEND | EXPR_PARENED | EXPR_STRING2177			| EXPR_NUMBER | EXPR_LITERAL | EXPR_ARRAY | EXPR_OBJECT | EXPR_ARRAY_COMP2178			| EXPR_IMPORT | EXPR_VAR | EXPR_IF_THEN_ELSE | EXPR_FUNCTION | EXPR_ERROR => true,2179			_ => false,2180		}2181	}2182	fn cast(syntax: SyntaxNode) -> Option<Self> {2183		let res = match syntax.kind() {2184			EXPR_BINARY => ExprBase::ExprBinary(ExprBinary { syntax }),2185			EXPR_UNARY => ExprBase::ExprUnary(ExprUnary { syntax }),2186			EXPR_OBJ_EXTEND => ExprBase::ExprObjExtend(ExprObjExtend { syntax }),2187			EXPR_PARENED => ExprBase::ExprParened(ExprParened { syntax }),2188			EXPR_STRING => ExprBase::ExprString(ExprString { syntax }),2189			EXPR_NUMBER => ExprBase::ExprNumber(ExprNumber { syntax }),2190			EXPR_LITERAL => ExprBase::ExprLiteral(ExprLiteral { syntax }),2191			EXPR_ARRAY => ExprBase::ExprArray(ExprArray { syntax }),2192			EXPR_OBJECT => ExprBase::ExprObject(ExprObject { syntax }),2193			EXPR_ARRAY_COMP => ExprBase::ExprArrayComp(ExprArrayComp { syntax }),2194			EXPR_IMPORT => ExprBase::ExprImport(ExprImport { syntax }),2195			EXPR_VAR => ExprBase::ExprVar(ExprVar { syntax }),2196			EXPR_IF_THEN_ELSE => ExprBase::ExprIfThenElse(ExprIfThenElse { syntax }),2197			EXPR_FUNCTION => ExprBase::ExprFunction(ExprFunction { syntax }),2198			EXPR_ERROR => ExprBase::ExprError(ExprError { syntax }),2199			_ => return None,2200		};2201		Some(res)2202	}2203	fn syntax(&self) -> &SyntaxNode {2204		match self {2205			ExprBase::ExprBinary(it) => &it.syntax,2206			ExprBase::ExprUnary(it) => &it.syntax,2207			ExprBase::ExprObjExtend(it) => &it.syntax,2208			ExprBase::ExprParened(it) => &it.syntax,2209			ExprBase::ExprString(it) => &it.syntax,2210			ExprBase::ExprNumber(it) => &it.syntax,2211			ExprBase::ExprLiteral(it) => &it.syntax,2212			ExprBase::ExprArray(it) => &it.syntax,2213			ExprBase::ExprObject(it) => &it.syntax,2214			ExprBase::ExprArrayComp(it) => &it.syntax,2215			ExprBase::ExprImport(it) => &it.syntax,2216			ExprBase::ExprVar(it) => &it.syntax,2217			ExprBase::ExprIfThenElse(it) => &it.syntax,2218			ExprBase::ExprFunction(it) => &it.syntax,2219			ExprBase::ExprError(it) => &it.syntax,2220		}2221	}2222}2223impl From<MemberBindStmt> for MemberComp {2224	fn from(node: MemberBindStmt) -> MemberComp {2225		MemberComp::MemberBindStmt(node)2226	}2227}2228impl From<MemberFieldNormal> for MemberComp {2229	fn from(node: MemberFieldNormal) -> MemberComp {2230		MemberComp::MemberFieldNormal(node)2231	}2232}2233impl From<MemberFieldMethod> for MemberComp {2234	fn from(node: MemberFieldMethod) -> MemberComp {2235		MemberComp::MemberFieldMethod(node)2236	}2237}2238impl AstNode for MemberComp {2239	fn can_cast(kind: SyntaxKind) -> bool {2240		match kind {2241			MEMBER_BIND_STMT | MEMBER_FIELD_NORMAL | MEMBER_FIELD_METHOD => true,2242			_ => false,2243		}2244	}2245	fn cast(syntax: SyntaxNode) -> Option<Self> {2246		let res = match syntax.kind() {2247			MEMBER_BIND_STMT => MemberComp::MemberBindStmt(MemberBindStmt { syntax }),2248			MEMBER_FIELD_NORMAL => MemberComp::MemberFieldNormal(MemberFieldNormal { syntax }),2249			MEMBER_FIELD_METHOD => MemberComp::MemberFieldMethod(MemberFieldMethod { syntax }),2250			_ => return None,2251		};2252		Some(res)2253	}2254	fn syntax(&self) -> &SyntaxNode {2255		match self {2256			MemberComp::MemberBindStmt(it) => &it.syntax,2257			MemberComp::MemberFieldNormal(it) => &it.syntax,2258			MemberComp::MemberFieldMethod(it) => &it.syntax,2259		}2260	}2261}2262impl From<MemberBindStmt> for Member {2263	fn from(node: MemberBindStmt) -> Member {2264		Member::MemberBindStmt(node)2265	}2266}2267impl From<MemberAssertStmt> for Member {2268	fn from(node: MemberAssertStmt) -> Member {2269		Member::MemberAssertStmt(node)2270	}2271}2272impl From<MemberFieldNormal> for Member {2273	fn from(node: MemberFieldNormal) -> Member {2274		Member::MemberFieldNormal(node)2275	}2276}2277impl From<MemberFieldMethod> for Member {2278	fn from(node: MemberFieldMethod) -> Member {2279		Member::MemberFieldMethod(node)2280	}2281}2282impl AstNode for Member {2283	fn can_cast(kind: SyntaxKind) -> bool {2284		match kind {2285			MEMBER_BIND_STMT | MEMBER_ASSERT_STMT | MEMBER_FIELD_NORMAL | MEMBER_FIELD_METHOD => {2286				true2287			}2288			_ => false,2289		}2290	}2291	fn cast(syntax: SyntaxNode) -> Option<Self> {2292		let res = match syntax.kind() {2293			MEMBER_BIND_STMT => Member::MemberBindStmt(MemberBindStmt { syntax }),2294			MEMBER_ASSERT_STMT => Member::MemberAssertStmt(MemberAssertStmt { syntax }),2295			MEMBER_FIELD_NORMAL => Member::MemberFieldNormal(MemberFieldNormal { syntax }),2296			MEMBER_FIELD_METHOD => Member::MemberFieldMethod(MemberFieldMethod { syntax }),2297			_ => return None,2298		};2299		Some(res)2300	}2301	fn syntax(&self) -> &SyntaxNode {2302		match self {2303			Member::MemberBindStmt(it) => &it.syntax,2304			Member::MemberAssertStmt(it) => &it.syntax,2305			Member::MemberFieldNormal(it) => &it.syntax,2306			Member::MemberFieldMethod(it) => &it.syntax,2307		}2308	}2309}2310impl From<FieldNameFixed> for FieldName {2311	fn from(node: FieldNameFixed) -> FieldName {2312		FieldName::FieldNameFixed(node)2313	}2314}2315impl From<FieldNameDynamic> for FieldName {2316	fn from(node: FieldNameDynamic) -> FieldName {2317		FieldName::FieldNameDynamic(node)2318	}2319}2320impl AstNode for FieldName {2321	fn can_cast(kind: SyntaxKind) -> bool {2322		match kind {2323			FIELD_NAME_FIXED | FIELD_NAME_DYNAMIC => true,2324			_ => false,2325		}2326	}2327	fn cast(syntax: SyntaxNode) -> Option<Self> {2328		let res = match syntax.kind() {2329			FIELD_NAME_FIXED => FieldName::FieldNameFixed(FieldNameFixed { syntax }),2330			FIELD_NAME_DYNAMIC => FieldName::FieldNameDynamic(FieldNameDynamic { syntax }),2331			_ => return None,2332		};2333		Some(res)2334	}2335	fn syntax(&self) -> &SyntaxNode {2336		match self {2337			FieldName::FieldNameFixed(it) => &it.syntax,2338			FieldName::FieldNameDynamic(it) => &it.syntax,2339		}2340	}2341}2342impl From<DestructFull> for Destruct {2343	fn from(node: DestructFull) -> Destruct {2344		Destruct::DestructFull(node)2345	}2346}2347impl From<DestructSkip> for Destruct {2348	fn from(node: DestructSkip) -> Destruct {2349		Destruct::DestructSkip(node)2350	}2351}2352impl From<DestructArray> for Destruct {2353	fn from(node: DestructArray) -> Destruct {2354		Destruct::DestructArray(node)2355	}2356}2357impl From<DestructObject> for Destruct {2358	fn from(node: DestructObject) -> Destruct {2359		Destruct::DestructObject(node)2360	}2361}2362impl AstNode for Destruct {2363	fn can_cast(kind: SyntaxKind) -> bool {2364		match kind {2365			DESTRUCT_FULL | DESTRUCT_SKIP | DESTRUCT_ARRAY | DESTRUCT_OBJECT => true,2366			_ => false,2367		}2368	}2369	fn cast(syntax: SyntaxNode) -> Option<Self> {2370		let res = match syntax.kind() {2371			DESTRUCT_FULL => Destruct::DestructFull(DestructFull { syntax }),2372			DESTRUCT_SKIP => Destruct::DestructSkip(DestructSkip { syntax }),2373			DESTRUCT_ARRAY => Destruct::DestructArray(DestructArray { syntax }),2374			DESTRUCT_OBJECT => Destruct::DestructObject(DestructObject { syntax }),2375			_ => return None,2376		};2377		Some(res)2378	}2379	fn syntax(&self) -> &SyntaxNode {2380		match self {2381			Destruct::DestructFull(it) => &it.syntax,2382			Destruct::DestructSkip(it) => &it.syntax,2383			Destruct::DestructArray(it) => &it.syntax,2384			Destruct::DestructObject(it) => &it.syntax,2385		}2386	}2387}2388impl From<DestructArrayElement> for DestructArrayPart {2389	fn from(node: DestructArrayElement) -> DestructArrayPart {2390		DestructArrayPart::DestructArrayElement(node)2391	}2392}2393impl From<DestructRest> for DestructArrayPart {2394	fn from(node: DestructRest) -> DestructArrayPart {2395		DestructArrayPart::DestructRest(node)2396	}2397}2398impl AstNode for DestructArrayPart {2399	fn can_cast(kind: SyntaxKind) -> bool {2400		match kind {2401			DESTRUCT_ARRAY_ELEMENT | DESTRUCT_REST => true,2402			_ => false,2403		}2404	}2405	fn cast(syntax: SyntaxNode) -> Option<Self> {2406		let res = match syntax.kind() {2407			DESTRUCT_ARRAY_ELEMENT => {2408				DestructArrayPart::DestructArrayElement(DestructArrayElement { syntax })2409			}2410			DESTRUCT_REST => DestructArrayPart::DestructRest(DestructRest { syntax }),2411			_ => return None,2412		};2413		Some(res)2414	}2415	fn syntax(&self) -> &SyntaxNode {2416		match self {2417			DestructArrayPart::DestructArrayElement(it) => &it.syntax,2418			DestructArrayPart::DestructRest(it) => &it.syntax,2419		}2420	}2421}2422impl AstToken for BinaryOperator {2423	fn can_cast(kind: SyntaxKind) -> bool {2424		BinaryOperatorKind::can_cast(kind)2425	}2426	fn cast(syntax: SyntaxToken) -> Option<Self> {2427		let kind = BinaryOperatorKind::cast(syntax.kind())?;2428		Some(BinaryOperator { syntax, kind })2429	}2430	fn syntax(&self) -> &SyntaxToken {2431		&self.syntax2432	}2433}2434impl BinaryOperatorKind {2435	fn can_cast(kind: SyntaxKind) -> bool {2436		match kind {2437			OR | NULL_COAELSE | AND | BIT_OR | BIT_XOR | BIT_AND | EQ | NE | LT | GT | LE | GE2438			| IN_KW | LHS | RHS | PLUS | MINUS | MUL | DIV | MODULO | META_OBJECT_APPLY2439			| ERROR_NO_OPERATOR => true,2440			_ => false,2441		}2442	}2443	pub fn cast(kind: SyntaxKind) -> Option<Self> {2444		let res = match kind {2445			OR => Self::Or,2446			NULL_COAELSE => Self::NullCoaelse,2447			AND => Self::And,2448			BIT_OR => Self::BitOr,2449			BIT_XOR => Self::BitXor,2450			BIT_AND => Self::BitAnd,2451			EQ => Self::Eq,2452			NE => Self::Ne,2453			LT => Self::Lt,2454			GT => Self::Gt,2455			LE => Self::Le,2456			GE => Self::Ge,2457			IN_KW => Self::InKw,2458			LHS => Self::Lhs,2459			RHS => Self::Rhs,2460			PLUS => Self::Plus,2461			MINUS => Self::Minus,2462			MUL => Self::Mul,2463			DIV => Self::Div,2464			MODULO => Self::Modulo,2465			META_OBJECT_APPLY => Self::MetaObjectApply,2466			ERROR_NO_OPERATOR => Self::ErrorNoOperator,2467			_ => return None,2468		};2469		Some(res)2470	}2471}2472impl BinaryOperator {2473	pub fn kind(&self) -> BinaryOperatorKind {2474		self.kind2475	}2476}2477impl std::fmt::Display for BinaryOperator {2478	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2479		std::fmt::Display::fmt(self.syntax(), f)2480	}2481}2482impl AstToken for UnaryOperator {2483	fn can_cast(kind: SyntaxKind) -> bool {2484		UnaryOperatorKind::can_cast(kind)2485	}2486	fn cast(syntax: SyntaxToken) -> Option<Self> {2487		let kind = UnaryOperatorKind::cast(syntax.kind())?;2488		Some(UnaryOperator { syntax, kind })2489	}2490	fn syntax(&self) -> &SyntaxToken {2491		&self.syntax2492	}2493}2494impl UnaryOperatorKind {2495	fn can_cast(kind: SyntaxKind) -> bool {2496		match kind {2497			MINUS | NOT | BIT_NOT => true,2498			_ => false,2499		}2500	}2501	pub fn cast(kind: SyntaxKind) -> Option<Self> {2502		let res = match kind {2503			MINUS => Self::Minus,2504			NOT => Self::Not,2505			BIT_NOT => Self::BitNot,2506			_ => return None,2507		};2508		Some(res)2509	}2510}2511impl UnaryOperator {2512	pub fn kind(&self) -> UnaryOperatorKind {2513		self.kind2514	}2515}2516impl std::fmt::Display for UnaryOperator {2517	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2518		std::fmt::Display::fmt(self.syntax(), f)2519	}2520}2521impl AstToken for Literal {2522	fn can_cast(kind: SyntaxKind) -> bool {2523		LiteralKind::can_cast(kind)2524	}2525	fn cast(syntax: SyntaxToken) -> Option<Self> {2526		let kind = LiteralKind::cast(syntax.kind())?;2527		Some(Literal { syntax, kind })2528	}2529	fn syntax(&self) -> &SyntaxToken {2530		&self.syntax2531	}2532}2533impl LiteralKind {2534	fn can_cast(kind: SyntaxKind) -> bool {2535		match kind {2536			NULL_KW | TRUE_KW | FALSE_KW | SELF_KW | DOLLAR | SUPER_KW => true,2537			_ => false,2538		}2539	}2540	pub fn cast(kind: SyntaxKind) -> Option<Self> {2541		let res = match kind {2542			NULL_KW => Self::NullKw,2543			TRUE_KW => Self::TrueKw,2544			FALSE_KW => Self::FalseKw,2545			SELF_KW => Self::SelfKw,2546			DOLLAR => Self::Dollar,2547			SUPER_KW => Self::SuperKw,2548			_ => return None,2549		};2550		Some(res)2551	}2552}2553impl Literal {2554	pub fn kind(&self) -> LiteralKind {2555		self.kind2556	}2557}2558impl std::fmt::Display for Literal {2559	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2560		std::fmt::Display::fmt(self.syntax(), f)2561	}2562}2563impl AstToken for Text {2564	fn can_cast(kind: SyntaxKind) -> bool {2565		TextKind::can_cast(kind)2566	}2567	fn cast(syntax: SyntaxToken) -> Option<Self> {2568		let kind = TextKind::cast(syntax.kind())?;2569		Some(Text { syntax, kind })2570	}2571	fn syntax(&self) -> &SyntaxToken {2572		&self.syntax2573	}2574}2575impl TextKind {2576	fn can_cast(kind: SyntaxKind) -> bool {2577		match kind {2578			STRING_DOUBLE2579			| ERROR_STRING_DOUBLE_UNTERMINATED2580			| STRING_SINGLE2581			| ERROR_STRING_SINGLE_UNTERMINATED2582			| STRING_DOUBLE_VERBATIM2583			| ERROR_STRING_DOUBLE_VERBATIM_UNTERMINATED2584			| STRING_SINGLE_VERBATIM2585			| ERROR_STRING_SINGLE_VERBATIM_UNTERMINATED2586			| ERROR_STRING_VERBATIM_MISSING_QUOTES2587			| STRING_BLOCK2588			| ERROR_STRING_BLOCK_UNEXPECTED_END2589			| ERROR_STRING_BLOCK_MISSING_NEW_LINE2590			| ERROR_STRING_BLOCK_MISSING_TERMINATION2591			| ERROR_STRING_BLOCK_MISSING_INDENT => true,2592			_ => false,2593		}2594	}2595	pub fn cast(kind: SyntaxKind) -> Option<Self> {2596		let res = match kind {2597			STRING_DOUBLE => Self::StringDouble,2598			ERROR_STRING_DOUBLE_UNTERMINATED => Self::ErrorStringDoubleUnterminated,2599			STRING_SINGLE => Self::StringSingle,2600			ERROR_STRING_SINGLE_UNTERMINATED => Self::ErrorStringSingleUnterminated,2601			STRING_DOUBLE_VERBATIM => Self::StringDoubleVerbatim,2602			ERROR_STRING_DOUBLE_VERBATIM_UNTERMINATED => {2603				Self::ErrorStringDoubleVerbatimUnterminated2604			}2605			STRING_SINGLE_VERBATIM => Self::StringSingleVerbatim,2606			ERROR_STRING_SINGLE_VERBATIM_UNTERMINATED => {2607				Self::ErrorStringSingleVerbatimUnterminated2608			}2609			ERROR_STRING_VERBATIM_MISSING_QUOTES => Self::ErrorStringVerbatimMissingQuotes,2610			STRING_BLOCK => Self::StringBlock,2611			ERROR_STRING_BLOCK_UNEXPECTED_END => Self::ErrorStringBlockUnexpectedEnd,2612			ERROR_STRING_BLOCK_MISSING_NEW_LINE => Self::ErrorStringBlockMissingNewLine,2613			ERROR_STRING_BLOCK_MISSING_TERMINATION => Self::ErrorStringBlockMissingTermination,2614			ERROR_STRING_BLOCK_MISSING_INDENT => Self::ErrorStringBlockMissingIndent,2615			_ => return None,2616		};2617		Some(res)2618	}2619}2620impl Text {2621	pub fn kind(&self) -> TextKind {2622		self.kind2623	}2624}2625impl std::fmt::Display for Text {2626	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2627		std::fmt::Display::fmt(self.syntax(), f)2628	}2629}2630impl AstToken for Number {2631	fn can_cast(kind: SyntaxKind) -> bool {2632		NumberKind::can_cast(kind)2633	}2634	fn cast(syntax: SyntaxToken) -> Option<Self> {2635		let kind = NumberKind::cast(syntax.kind())?;2636		Some(Number { syntax, kind })2637	}2638	fn syntax(&self) -> &SyntaxToken {2639		&self.syntax2640	}2641}2642impl NumberKind {2643	fn can_cast(kind: SyntaxKind) -> bool {2644		match kind {2645			FLOAT2646			| ERROR_FLOAT_JUNK_AFTER_POINT2647			| ERROR_FLOAT_JUNK_AFTER_EXPONENT2648			| ERROR_FLOAT_JUNK_AFTER_EXPONENT_SIGN => true,2649			_ => false,2650		}2651	}2652	pub fn cast(kind: SyntaxKind) -> Option<Self> {2653		let res = match kind {2654			FLOAT => Self::Float,2655			ERROR_FLOAT_JUNK_AFTER_POINT => Self::ErrorFloatJunkAfterPoint,2656			ERROR_FLOAT_JUNK_AFTER_EXPONENT => Self::ErrorFloatJunkAfterExponent,2657			ERROR_FLOAT_JUNK_AFTER_EXPONENT_SIGN => Self::ErrorFloatJunkAfterExponentSign,2658			_ => return None,2659		};2660		Some(res)2661	}2662}2663impl Number {2664	pub fn kind(&self) -> NumberKind {2665		self.kind2666	}2667}2668impl std::fmt::Display for Number {2669	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2670		std::fmt::Display::fmt(self.syntax(), f)2671	}2672}2673impl AstToken for ImportKind {2674	fn can_cast(kind: SyntaxKind) -> bool {2675		ImportKindKind::can_cast(kind)2676	}2677	fn cast(syntax: SyntaxToken) -> Option<Self> {2678		let kind = ImportKindKind::cast(syntax.kind())?;2679		Some(ImportKind { syntax, kind })2680	}2681	fn syntax(&self) -> &SyntaxToken {2682		&self.syntax2683	}2684}2685impl ImportKindKind {2686	fn can_cast(kind: SyntaxKind) -> bool {2687		match kind {2688			IMPORTSTR_KW | IMPORTBIN_KW | IMPORT_KW => true,2689			_ => false,2690		}2691	}2692	pub fn cast(kind: SyntaxKind) -> Option<Self> {2693		let res = match kind {2694			IMPORTSTR_KW => Self::ImportstrKw,2695			IMPORTBIN_KW => Self::ImportbinKw,2696			IMPORT_KW => Self::ImportKw,2697			_ => return None,2698		};2699		Some(res)2700	}2701}2702impl ImportKind {2703	pub fn kind(&self) -> ImportKindKind {2704		self.kind2705	}2706}2707impl std::fmt::Display for ImportKind {2708	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2709		std::fmt::Display::fmt(self.syntax(), f)2710	}2711}2712impl AstToken for Trivia {2713	fn can_cast(kind: SyntaxKind) -> bool {2714		TriviaKind::can_cast(kind)2715	}2716	fn cast(syntax: SyntaxToken) -> Option<Self> {2717		let kind = TriviaKind::cast(syntax.kind())?;2718		Some(Trivia { syntax, kind })2719	}2720	fn syntax(&self) -> &SyntaxToken {2721		&self.syntax2722	}2723}2724impl TriviaKind {2725	fn can_cast(kind: SyntaxKind) -> bool {2726		match kind {2727			WHITESPACE2728			| MULTI_LINE_COMMENT2729			| ERROR_COMMENT_TOO_SHORT2730			| ERROR_COMMENT_UNTERMINATED2731			| SINGLE_LINE_HASH_COMMENT2732			| SINGLE_LINE_SLASH_COMMENT => true,2733			_ => false,2734		}2735	}2736	pub fn cast(kind: SyntaxKind) -> Option<Self> {2737		let res = match kind {2738			WHITESPACE => Self::Whitespace,2739			MULTI_LINE_COMMENT => Self::MultiLineComment,2740			ERROR_COMMENT_TOO_SHORT => Self::ErrorCommentTooShort,2741			ERROR_COMMENT_UNTERMINATED => Self::ErrorCommentUnterminated,2742			SINGLE_LINE_HASH_COMMENT => Self::SingleLineHashComment,2743			SINGLE_LINE_SLASH_COMMENT => Self::SingleLineSlashComment,2744			_ => return None,2745		};2746		Some(res)2747	}2748}2749impl Trivia {2750	pub fn kind(&self) -> TriviaKind {2751		self.kind2752	}2753}2754impl std::fmt::Display for Trivia {2755	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2756		std::fmt::Display::fmt(self.syntax(), f)2757	}2758}2759impl AstToken for CustomError {2760	fn can_cast(kind: SyntaxKind) -> bool {2761		CustomErrorKind::can_cast(kind)2762	}2763	fn cast(syntax: SyntaxToken) -> Option<Self> {2764		let kind = CustomErrorKind::cast(syntax.kind())?;2765		Some(CustomError { syntax, kind })2766	}2767	fn syntax(&self) -> &SyntaxToken {2768		&self.syntax2769	}2770}2771impl CustomErrorKind {2772	fn can_cast(kind: SyntaxKind) -> bool {2773		match kind {2774			ERROR_MISSING_TOKEN | ERROR_UNEXPECTED_TOKEN | ERROR_CUSTOM => true,2775			_ => false,2776		}2777	}2778	pub fn cast(kind: SyntaxKind) -> Option<Self> {2779		let res = match kind {2780			ERROR_MISSING_TOKEN => Self::ErrorMissingToken,2781			ERROR_UNEXPECTED_TOKEN => Self::ErrorUnexpectedToken,2782			ERROR_CUSTOM => Self::ErrorCustom,2783			_ => return None,2784		};2785		Some(res)2786	}2787}2788impl CustomError {2789	pub fn kind(&self) -> CustomErrorKind {2790		self.kind2791	}2792}2793impl std::fmt::Display for CustomError {2794	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2795		std::fmt::Display::fmt(self.syntax(), f)2796	}2797}2798impl std::fmt::Display for Suffix {2799	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2800		std::fmt::Display::fmt(self.syntax(), f)2801	}2802}2803impl std::fmt::Display for Bind {2804	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2805		std::fmt::Display::fmt(self.syntax(), f)2806	}2807}2808impl std::fmt::Display for Stmt {2809	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2810		std::fmt::Display::fmt(self.syntax(), f)2811	}2812}2813impl std::fmt::Display for ObjBody {2814	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2815		std::fmt::Display::fmt(self.syntax(), f)2816	}2817}2818impl std::fmt::Display for CompSpec {2819	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2820		std::fmt::Display::fmt(self.syntax(), f)2821	}2822}2823impl std::fmt::Display for ExprBase {2824	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2825		std::fmt::Display::fmt(self.syntax(), f)2826	}2827}2828impl std::fmt::Display for MemberComp {2829	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2830		std::fmt::Display::fmt(self.syntax(), f)2831	}2832}2833impl std::fmt::Display for Member {2834	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2835		std::fmt::Display::fmt(self.syntax(), f)2836	}2837}2838impl std::fmt::Display for FieldName {2839	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2840		std::fmt::Display::fmt(self.syntax(), f)2841	}2842}2843impl std::fmt::Display for Destruct {2844	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2845		std::fmt::Display::fmt(self.syntax(), f)2846	}2847}2848impl std::fmt::Display for DestructArrayPart {2849	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2850		std::fmt::Display::fmt(self.syntax(), f)2851	}2852}2853impl std::fmt::Display for SourceFile {2854	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2855		std::fmt::Display::fmt(self.syntax(), f)2856	}2857}2858impl std::fmt::Display for Expr {2859	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2860		std::fmt::Display::fmt(self.syntax(), f)2861	}2862}2863impl std::fmt::Display for SuffixIndex {2864	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2865		std::fmt::Display::fmt(self.syntax(), f)2866	}2867}2868impl std::fmt::Display for Name {2869	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2870		std::fmt::Display::fmt(self.syntax(), f)2871	}2872}2873impl std::fmt::Display for SuffixIndexExpr {2874	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2875		std::fmt::Display::fmt(self.syntax(), f)2876	}2877}2878impl std::fmt::Display for SuffixSlice {2879	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2880		std::fmt::Display::fmt(self.syntax(), f)2881	}2882}2883impl std::fmt::Display for SliceDesc {2884	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2885		std::fmt::Display::fmt(self.syntax(), f)2886	}2887}2888impl std::fmt::Display for SuffixApply {2889	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2890		std::fmt::Display::fmt(self.syntax(), f)2891	}2892}2893impl std::fmt::Display for ArgsDesc {2894	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2895		std::fmt::Display::fmt(self.syntax(), f)2896	}2897}2898impl std::fmt::Display for StmtLocal {2899	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2900		std::fmt::Display::fmt(self.syntax(), f)2901	}2902}2903impl std::fmt::Display for StmtAssert {2904	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2905		std::fmt::Display::fmt(self.syntax(), f)2906	}2907}2908impl std::fmt::Display for Assertion {2909	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2910		std::fmt::Display::fmt(self.syntax(), f)2911	}2912}2913impl std::fmt::Display for ExprBinary {2914	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2915		std::fmt::Display::fmt(self.syntax(), f)2916	}2917}2918impl std::fmt::Display for ExprUnary {2919	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2920		std::fmt::Display::fmt(self.syntax(), f)2921	}2922}2923impl std::fmt::Display for ExprObjExtend {2924	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2925		std::fmt::Display::fmt(self.syntax(), f)2926	}2927}2928impl std::fmt::Display for ExprParened {2929	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2930		std::fmt::Display::fmt(self.syntax(), f)2931	}2932}2933impl std::fmt::Display for ExprLiteral {2934	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2935		std::fmt::Display::fmt(self.syntax(), f)2936	}2937}2938impl std::fmt::Display for ExprString {2939	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2940		std::fmt::Display::fmt(self.syntax(), f)2941	}2942}2943impl std::fmt::Display for ExprNumber {2944	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2945		std::fmt::Display::fmt(self.syntax(), f)2946	}2947}2948impl std::fmt::Display for ExprArray {2949	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2950		std::fmt::Display::fmt(self.syntax(), f)2951	}2952}2953impl std::fmt::Display for ExprObject {2954	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2955		std::fmt::Display::fmt(self.syntax(), f)2956	}2957}2958impl std::fmt::Display for ExprArrayComp {2959	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2960		std::fmt::Display::fmt(self.syntax(), f)2961	}2962}2963impl std::fmt::Display for ExprImport {2964	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2965		std::fmt::Display::fmt(self.syntax(), f)2966	}2967}2968impl std::fmt::Display for ExprVar {2969	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2970		std::fmt::Display::fmt(self.syntax(), f)2971	}2972}2973impl std::fmt::Display for ExprIfThenElse {2974	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2975		std::fmt::Display::fmt(self.syntax(), f)2976	}2977}2978impl std::fmt::Display for TrueExpr {2979	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2980		std::fmt::Display::fmt(self.syntax(), f)2981	}2982}2983impl std::fmt::Display for FalseExpr {2984	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2985		std::fmt::Display::fmt(self.syntax(), f)2986	}2987}2988impl std::fmt::Display for ExprFunction {2989	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2990		std::fmt::Display::fmt(self.syntax(), f)2991	}2992}2993impl std::fmt::Display for ParamsDesc {2994	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2995		std::fmt::Display::fmt(self.syntax(), f)2996	}2997}2998impl std::fmt::Display for ExprError {2999	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3000		std::fmt::Display::fmt(self.syntax(), f)3001	}3002}3003impl std::fmt::Display for SliceDescEnd {3004	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3005		std::fmt::Display::fmt(self.syntax(), f)3006	}3007}3008impl std::fmt::Display for SliceDescStep {3009	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3010		std::fmt::Display::fmt(self.syntax(), f)3011	}3012}3013impl std::fmt::Display for Arg {3014	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3015		std::fmt::Display::fmt(self.syntax(), f)3016	}3017}3018impl std::fmt::Display for ObjBodyComp {3019	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3020		std::fmt::Display::fmt(self.syntax(), f)3021	}3022}3023impl std::fmt::Display for ObjBodyMemberList {3024	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3025		std::fmt::Display::fmt(self.syntax(), f)3026	}3027}3028impl std::fmt::Display for MemberBindStmt {3029	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3030		std::fmt::Display::fmt(self.syntax(), f)3031	}3032}3033impl std::fmt::Display for ObjLocal {3034	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3035		std::fmt::Display::fmt(self.syntax(), f)3036	}3037}3038impl std::fmt::Display for MemberAssertStmt {3039	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3040		std::fmt::Display::fmt(self.syntax(), f)3041	}3042}3043impl std::fmt::Display for MemberFieldNormal {3044	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3045		std::fmt::Display::fmt(self.syntax(), f)3046	}3047}3048impl std::fmt::Display for Visibility {3049	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3050		std::fmt::Display::fmt(self.syntax(), f)3051	}3052}3053impl std::fmt::Display for MemberFieldMethod {3054	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3055		std::fmt::Display::fmt(self.syntax(), f)3056	}3057}3058impl std::fmt::Display for FieldNameFixed {3059	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3060		std::fmt::Display::fmt(self.syntax(), f)3061	}3062}3063impl std::fmt::Display for FieldNameDynamic {3064	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3065		std::fmt::Display::fmt(self.syntax(), f)3066	}3067}3068impl std::fmt::Display for ForSpec {3069	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3070		std::fmt::Display::fmt(self.syntax(), f)3071	}3072}3073impl std::fmt::Display for ForObjSpec {3074	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3075		std::fmt::Display::fmt(self.syntax(), f)3076	}3077}3078impl std::fmt::Display for IfSpec {3079	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3080		std::fmt::Display::fmt(self.syntax(), f)3081	}3082}3083impl std::fmt::Display for BindDestruct {3084	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3085		std::fmt::Display::fmt(self.syntax(), f)3086	}3087}3088impl std::fmt::Display for BindFunction {3089	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3090		std::fmt::Display::fmt(self.syntax(), f)3091	}3092}3093impl std::fmt::Display for Param {3094	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3095		std::fmt::Display::fmt(self.syntax(), f)3096	}3097}3098impl std::fmt::Display for DestructFull {3099	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3100		std::fmt::Display::fmt(self.syntax(), f)3101	}3102}3103impl std::fmt::Display for DestructSkip {3104	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3105		std::fmt::Display::fmt(self.syntax(), f)3106	}3107}3108impl std::fmt::Display for DestructArray {3109	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3110		std::fmt::Display::fmt(self.syntax(), f)3111	}3112}3113impl std::fmt::Display for DestructObject {3114	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3115		std::fmt::Display::fmt(self.syntax(), f)3116	}3117}3118impl std::fmt::Display for DestructObjectField {3119	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3120		std::fmt::Display::fmt(self.syntax(), f)3121	}3122}3123impl std::fmt::Display for DestructRest {3124	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3125		std::fmt::Display::fmt(self.syntax(), f)3126	}3127}3128impl std::fmt::Display for DestructArrayElement {3129	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3130		std::fmt::Display::fmt(self.syntax(), f)3131	}3132}