git.delta.rocks / jrsonnet / refs/commits / 26a3b24cc9cf

1//! This is a generated file, please do not edit manually. Changes can be2//! made in codegeneration that lives in `xtask` top-level dir.34#![allow(non_snake_case, clippy::match_like_matches_macro)]5use crate::{6	ast::{support, AstChildren, AstNode, AstToken},7	SyntaxKind::{self, *},8	SyntaxNode, SyntaxToken, T,9};1011#[derive(Debug, Clone, PartialEq, Eq, Hash)]12pub struct SourceFile {13	pub(crate) syntax: SyntaxNode,14}15impl SourceFile {16	pub fn expr(&self) -> Option<Expr> {17		support::child(&self.syntax)18	}19}2021#[derive(Debug, Clone, PartialEq, Eq, Hash)]22pub struct ExprBinary {23	pub(crate) syntax: SyntaxNode,24}25impl ExprBinary {26	pub fn lhs(&self) -> Option<LhsExpr> {27		support::child(&self.syntax)28	}29	pub fn binary_operator(&self) -> Option<BinaryOperator> {30		support::token_child(&self.syntax)31	}32	pub fn rhs(&self) -> Option<Expr> {33		support::child(&self.syntax)34	}35}3637#[derive(Debug, Clone, PartialEq, Eq, Hash)]38pub struct LhsExpr {39	pub(crate) syntax: SyntaxNode,40}41impl LhsExpr {42	pub fn expr(&self) -> Option<Expr> {43		support::child(&self.syntax)44	}45}4647#[derive(Debug, Clone, PartialEq, Eq, Hash)]48pub struct ExprUnary {49	pub(crate) syntax: SyntaxNode,50}51impl ExprUnary {52	pub fn unary_operator(&self) -> Option<UnaryOperator> {53		support::token_child(&self.syntax)54	}55	pub fn rhs(&self) -> Option<Expr> {56		support::child(&self.syntax)57	}58}5960#[derive(Debug, Clone, PartialEq, Eq, Hash)]61pub struct ExprSlice {62	pub(crate) syntax: SyntaxNode,63}64impl ExprSlice {65	pub fn expr(&self) -> Option<Expr> {66		support::child(&self.syntax)67	}68	pub fn slice_desc(&self) -> Option<SliceDesc> {69		support::child(&self.syntax)70	}71}7273#[derive(Debug, Clone, PartialEq, Eq, Hash)]74pub struct SliceDesc {75	pub(crate) syntax: SyntaxNode,76}77impl SliceDesc {78	pub fn l_brack_token(&self) -> Option<SyntaxToken> {79		support::token(&self.syntax, T!['['])80	}81	pub fn from(&self) -> Option<Expr> {82		support::child(&self.syntax)83	}84	pub fn colon_token(&self) -> Option<SyntaxToken> {85		support::token(&self.syntax, T![:])86	}87	pub fn end(&self) -> Option<SliceDescEnd> {88		support::child(&self.syntax)89	}90	pub fn step(&self) -> Option<SliceDescStep> {91		support::child(&self.syntax)92	}93	pub fn r_brack_token(&self) -> Option<SyntaxToken> {94		support::token(&self.syntax, T![']'])95	}96}9798#[derive(Debug, Clone, PartialEq, Eq, Hash)]99pub struct ExprIndex {100	pub(crate) syntax: SyntaxNode,101}102impl ExprIndex {103	pub fn expr(&self) -> Option<Expr> {104		support::child(&self.syntax)105	}106	pub fn dot_token(&self) -> Option<SyntaxToken> {107		support::token(&self.syntax, T![.])108	}109	pub fn index(&self) -> Option<Name> {110		support::child(&self.syntax)111	}112}113114#[derive(Debug, Clone, PartialEq, Eq, Hash)]115pub struct Name {116	pub(crate) syntax: SyntaxNode,117}118impl Name {119	pub fn ident_lit(&self) -> Option<SyntaxToken> {120		support::token(&self.syntax, IDENT)121	}122}123124#[derive(Debug, Clone, PartialEq, Eq, Hash)]125pub struct ExprIndexExpr {126	pub(crate) syntax: SyntaxNode,127}128impl ExprIndexExpr {129	pub fn base(&self) -> Option<LhsExpr> {130		support::child(&self.syntax)131	}132	pub fn l_brack_token(&self) -> Option<SyntaxToken> {133		support::token(&self.syntax, T!['['])134	}135	pub fn index(&self) -> Option<Expr> {136		support::child(&self.syntax)137	}138	pub fn r_brack_token(&self) -> Option<SyntaxToken> {139		support::token(&self.syntax, T![']'])140	}141}142143#[derive(Debug, Clone, PartialEq, Eq, Hash)]144pub struct ExprApply {145	pub(crate) syntax: SyntaxNode,146}147impl ExprApply {148	pub fn expr(&self) -> Option<Expr> {149		support::child(&self.syntax)150	}151	pub fn args_desc(&self) -> Option<ArgsDesc> {152		support::child(&self.syntax)153	}154	pub fn tailstrict_kw_token(&self) -> Option<SyntaxToken> {155		support::token(&self.syntax, T![tailstrict])156	}157}158159#[derive(Debug, Clone, PartialEq, Eq, Hash)]160pub struct ArgsDesc {161	pub(crate) syntax: SyntaxNode,162}163impl ArgsDesc {164	pub fn l_paren_token(&self) -> Option<SyntaxToken> {165		support::token(&self.syntax, T!['('])166	}167	pub fn args(&self) -> AstChildren<Arg> {168		support::children(&self.syntax)169	}170	pub fn r_paren_token(&self) -> Option<SyntaxToken> {171		support::token(&self.syntax, T![')'])172	}173}174175#[derive(Debug, Clone, PartialEq, Eq, Hash)]176pub struct ExprObjExtend {177	pub(crate) syntax: SyntaxNode,178}179impl ExprObjExtend {180	pub fn lhs_expr(&self) -> Option<LhsExpr> {181		support::child(&self.syntax)182	}183	pub fn expr(&self) -> Option<Expr> {184		support::child(&self.syntax)185	}186}187188#[derive(Debug, Clone, PartialEq, Eq, Hash)]189pub struct ExprParened {190	pub(crate) syntax: SyntaxNode,191}192impl ExprParened {193	pub fn l_paren_token(&self) -> Option<SyntaxToken> {194		support::token(&self.syntax, T!['('])195	}196	pub fn expr(&self) -> Option<Expr> {197		support::child(&self.syntax)198	}199	pub fn r_paren_token(&self) -> Option<SyntaxToken> {200		support::token(&self.syntax, T![')'])201	}202}203204#[derive(Debug, Clone, PartialEq, Eq, Hash)]205pub struct ExprLiteral {206	pub(crate) syntax: SyntaxNode,207}208impl ExprLiteral {209	pub fn literal(&self) -> Option<Literal> {210		support::token_child(&self.syntax)211	}212}213214#[derive(Debug, Clone, PartialEq, Eq, Hash)]215pub struct ExprIntrinsicThisFile {216	pub(crate) syntax: SyntaxNode,217}218impl ExprIntrinsicThisFile {219	pub fn intrinsic_this_file_token(&self) -> Option<SyntaxToken> {220		support::token(&self.syntax, T!["$intrinsicThisFile"])221	}222}223224#[derive(Debug, Clone, PartialEq, Eq, Hash)]225pub struct ExprIntrinsicId {226	pub(crate) syntax: SyntaxNode,227}228impl ExprIntrinsicId {229	pub fn intrinsic_id_token(&self) -> Option<SyntaxToken> {230		support::token(&self.syntax, T!["$intrinsicId"])231	}232}233234#[derive(Debug, Clone, PartialEq, Eq, Hash)]235pub struct ExprIntrinsic {236	pub(crate) syntax: SyntaxNode,237}238impl ExprIntrinsic {239	pub fn intrinsic_token(&self) -> Option<SyntaxToken> {240		support::token(&self.syntax, T!["$intrinsic"])241	}242	pub fn l_paren_token(&self) -> Option<SyntaxToken> {243		support::token(&self.syntax, T!['('])244	}245	pub fn name(&self) -> Option<Name> {246		support::child(&self.syntax)247	}248	pub fn r_paren_token(&self) -> Option<SyntaxToken> {249		support::token(&self.syntax, T![')'])250	}251}252253#[derive(Debug, Clone, PartialEq, Eq, Hash)]254pub struct ExprString {255	pub(crate) syntax: SyntaxNode,256}257impl ExprString {258	pub fn text(&self) -> Option<Text> {259		support::token_child(&self.syntax)260	}261}262263#[derive(Debug, Clone, PartialEq, Eq, Hash)]264pub struct ExprNumber {265	pub(crate) syntax: SyntaxNode,266}267impl ExprNumber {268	pub fn number(&self) -> Option<Number> {269		support::token_child(&self.syntax)270	}271}272273#[derive(Debug, Clone, PartialEq, Eq, Hash)]274pub struct ExprArray {275	pub(crate) syntax: SyntaxNode,276}277impl ExprArray {278	pub fn l_brack_token(&self) -> Option<SyntaxToken> {279		support::token(&self.syntax, T!['['])280	}281	pub fn exprs(&self) -> AstChildren<Expr> {282		support::children(&self.syntax)283	}284	pub fn r_brack_token(&self) -> Option<SyntaxToken> {285		support::token(&self.syntax, T![']'])286	}287}288289#[derive(Debug, Clone, PartialEq, Eq, Hash)]290pub struct ExprObject {291	pub(crate) syntax: SyntaxNode,292}293impl ExprObject {294	pub fn obj_body(&self) -> Option<ObjBody> {295		support::child(&self.syntax)296	}297}298299#[derive(Debug, Clone, PartialEq, Eq, Hash)]300pub struct ExprArrayComp {301	pub(crate) syntax: SyntaxNode,302}303impl ExprArrayComp {304	pub fn l_brack_token(&self) -> Option<SyntaxToken> {305		support::token(&self.syntax, T!['['])306	}307	pub fn expr(&self) -> Option<Expr> {308		support::child(&self.syntax)309	}310	pub fn comma_token(&self) -> Option<SyntaxToken> {311		support::token(&self.syntax, T![,])312	}313	pub fn comp_specs(&self) -> AstChildren<CompSpec> {314		support::children(&self.syntax)315	}316	pub fn r_brack_token(&self) -> Option<SyntaxToken> {317		support::token(&self.syntax, T![']'])318	}319}320321#[derive(Debug, Clone, PartialEq, Eq, Hash)]322pub struct ExprImport {323	pub(crate) syntax: SyntaxNode,324}325impl ExprImport {326	pub fn import_kind(&self) -> Option<ImportKind> {327		support::token_child(&self.syntax)328	}329	pub fn text(&self) -> Option<Text> {330		support::token_child(&self.syntax)331	}332}333334#[derive(Debug, Clone, PartialEq, Eq, Hash)]335pub struct ExprVar {336	pub(crate) syntax: SyntaxNode,337}338impl ExprVar {339	pub fn name(&self) -> Option<Name> {340		support::child(&self.syntax)341	}342}343344#[derive(Debug, Clone, PartialEq, Eq, Hash)]345pub struct ExprLocal {346	pub(crate) syntax: SyntaxNode,347}348impl ExprLocal {349	pub fn local_kw_token(&self) -> Option<SyntaxToken> {350		support::token(&self.syntax, T![local])351	}352	pub fn binds(&self) -> AstChildren<Bind> {353		support::children(&self.syntax)354	}355	pub fn semi_token(&self) -> Option<SyntaxToken> {356		support::token(&self.syntax, T![;])357	}358	pub fn expr(&self) -> Option<Expr> {359		support::child(&self.syntax)360	}361}362363#[derive(Debug, Clone, PartialEq, Eq, Hash)]364pub struct ExprIfThenElse {365	pub(crate) syntax: SyntaxNode,366}367impl ExprIfThenElse {368	pub fn if_kw_token(&self) -> Option<SyntaxToken> {369		support::token(&self.syntax, T![if])370	}371	pub fn cond(&self) -> Option<Expr> {372		support::child(&self.syntax)373	}374	pub fn then_kw_token(&self) -> Option<SyntaxToken> {375		support::token(&self.syntax, T![then])376	}377	pub fn then(&self) -> Option<TrueExpr> {378		support::child(&self.syntax)379	}380	pub fn else_kw_token(&self) -> Option<SyntaxToken> {381		support::token(&self.syntax, T![else])382	}383	pub fn else_(&self) -> Option<FalseExpr> {384		support::child(&self.syntax)385	}386}387388#[derive(Debug, Clone, PartialEq, Eq, Hash)]389pub struct TrueExpr {390	pub(crate) syntax: SyntaxNode,391}392impl TrueExpr {393	pub fn expr(&self) -> Option<Expr> {394		support::child(&self.syntax)395	}396}397398#[derive(Debug, Clone, PartialEq, Eq, Hash)]399pub struct FalseExpr {400	pub(crate) syntax: SyntaxNode,401}402impl FalseExpr {403	pub fn expr(&self) -> Option<Expr> {404		support::child(&self.syntax)405	}406}407408#[derive(Debug, Clone, PartialEq, Eq, Hash)]409pub struct ExprFunction {410	pub(crate) syntax: SyntaxNode,411}412impl ExprFunction {413	pub fn function_kw_token(&self) -> Option<SyntaxToken> {414		support::token(&self.syntax, T![function])415	}416	pub fn l_paren_token(&self) -> Option<SyntaxToken> {417		support::token(&self.syntax, T!['('])418	}419	pub fn params_desc(&self) -> Option<ParamsDesc> {420		support::child(&self.syntax)421	}422	pub fn r_paren_token(&self) -> Option<SyntaxToken> {423		support::token(&self.syntax, T![')'])424	}425	pub fn expr(&self) -> Option<Expr> {426		support::child(&self.syntax)427	}428}429430#[derive(Debug, Clone, PartialEq, Eq, Hash)]431pub struct ParamsDesc {432	pub(crate) syntax: SyntaxNode,433}434impl ParamsDesc {435	pub fn l_paren_token(&self) -> Option<SyntaxToken> {436		support::token(&self.syntax, T!['('])437	}438	pub fn params(&self) -> AstChildren<Param> {439		support::children(&self.syntax)440	}441	pub fn r_paren_token(&self) -> Option<SyntaxToken> {442		support::token(&self.syntax, T![')'])443	}444}445446#[derive(Debug, Clone, PartialEq, Eq, Hash)]447pub struct ExprAssert {448	pub(crate) syntax: SyntaxNode,449}450impl ExprAssert {451	pub fn assertion(&self) -> Option<Assertion> {452		support::child(&self.syntax)453	}454	pub fn semi_token(&self) -> Option<SyntaxToken> {455		support::token(&self.syntax, T![;])456	}457	pub fn expr(&self) -> Option<Expr> {458		support::child(&self.syntax)459	}460}461462#[derive(Debug, Clone, PartialEq, Eq, Hash)]463pub struct Assertion {464	pub(crate) syntax: SyntaxNode,465}466impl Assertion {467	pub fn assert_kw_token(&self) -> Option<SyntaxToken> {468		support::token(&self.syntax, T![assert])469	}470	pub fn condition(&self) -> Option<LhsExpr> {471		support::child(&self.syntax)472	}473	pub fn colon_token(&self) -> Option<SyntaxToken> {474		support::token(&self.syntax, T![:])475	}476	pub fn message(&self) -> Option<Expr> {477		support::child(&self.syntax)478	}479}480481#[derive(Debug, Clone, PartialEq, Eq, Hash)]482pub struct ExprError {483	pub(crate) syntax: SyntaxNode,484}485impl ExprError {486	pub fn error_kw_token(&self) -> Option<SyntaxToken> {487		support::token(&self.syntax, T![error])488	}489	pub fn expr(&self) -> Option<Expr> {490		support::child(&self.syntax)491	}492}493494#[derive(Debug, Clone, PartialEq, Eq, Hash)]495pub struct SliceDescEnd {496	pub(crate) syntax: SyntaxNode,497}498impl SliceDescEnd {499	pub fn expr(&self) -> Option<Expr> {500		support::child(&self.syntax)501	}502}503504#[derive(Debug, Clone, PartialEq, Eq, Hash)]505pub struct SliceDescStep {506	pub(crate) syntax: SyntaxNode,507}508impl SliceDescStep {509	pub fn expr(&self) -> Option<Expr> {510		support::child(&self.syntax)511	}512}513514#[derive(Debug, Clone, PartialEq, Eq, Hash)]515pub struct Arg {516	pub(crate) syntax: SyntaxNode,517}518impl Arg {519	pub fn name(&self) -> Option<Name> {520		support::child(&self.syntax)521	}522	pub fn assign_token(&self) -> Option<SyntaxToken> {523		support::token(&self.syntax, T![=])524	}525	pub fn expr(&self) -> Option<Expr> {526		support::child(&self.syntax)527	}528}529530#[derive(Debug, Clone, PartialEq, Eq, Hash)]531pub struct ObjBodyComp {532	pub(crate) syntax: SyntaxNode,533}534impl ObjBodyComp {535	pub fn l_brace_token(&self) -> Option<SyntaxToken> {536		support::token(&self.syntax, T!['{'])537	}538	pub fn pre(&self) -> AstChildren<ObjLocalPostComma> {539		support::children(&self.syntax)540	}541	pub fn l_brack_token(&self) -> Option<SyntaxToken> {542		support::token(&self.syntax, T!['['])543	}544	pub fn key(&self) -> Option<LhsExpr> {545		support::child(&self.syntax)546	}547	pub fn r_brack_token(&self) -> Option<SyntaxToken> {548		support::token(&self.syntax, T![']'])549	}550	pub fn plus_token(&self) -> Option<SyntaxToken> {551		support::token(&self.syntax, T![+])552	}553	pub fn colon_token(&self) -> Option<SyntaxToken> {554		support::token(&self.syntax, T![:])555	}556	pub fn value(&self) -> Option<Expr> {557		support::child(&self.syntax)558	}559	pub fn post(&self) -> AstChildren<ObjLocalPreComma> {560		support::children(&self.syntax)561	}562	pub fn comp_specs(&self) -> AstChildren<CompSpec> {563		support::children(&self.syntax)564	}565	pub fn r_brace_token(&self) -> Option<SyntaxToken> {566		support::token(&self.syntax, T!['}'])567	}568}569570#[derive(Debug, Clone, PartialEq, Eq, Hash)]571pub struct ObjLocalPostComma {572	pub(crate) syntax: SyntaxNode,573}574impl ObjLocalPostComma {575	pub fn obj_local(&self) -> Option<ObjLocal> {576		support::child(&self.syntax)577	}578	pub fn comma_token(&self) -> Option<SyntaxToken> {579		support::token(&self.syntax, T![,])580	}581}582583#[derive(Debug, Clone, PartialEq, Eq, Hash)]584pub struct ObjLocalPreComma {585	pub(crate) syntax: SyntaxNode,586}587impl ObjLocalPreComma {588	pub fn comma_token(&self) -> Option<SyntaxToken> {589		support::token(&self.syntax, T![,])590	}591	pub fn obj_local(&self) -> Option<ObjLocal> {592		support::child(&self.syntax)593	}594}595596#[derive(Debug, Clone, PartialEq, Eq, Hash)]597pub struct ObjBodyMemberList {598	pub(crate) syntax: SyntaxNode,599}600impl ObjBodyMemberList {601	pub fn l_brace_token(&self) -> Option<SyntaxToken> {602		support::token(&self.syntax, T!['{'])603	}604	pub fn members(&self) -> AstChildren<Member> {605		support::children(&self.syntax)606	}607	pub fn r_brace_token(&self) -> Option<SyntaxToken> {608		support::token(&self.syntax, T!['}'])609	}610}611612#[derive(Debug, Clone, PartialEq, Eq, Hash)]613pub struct ObjLocal {614	pub(crate) syntax: SyntaxNode,615}616impl ObjLocal {617	pub fn local_kw_token(&self) -> Option<SyntaxToken> {618		support::token(&self.syntax, T![local])619	}620	pub fn bind(&self) -> Option<Bind> {621		support::child(&self.syntax)622	}623}624625#[derive(Debug, Clone, PartialEq, Eq, Hash)]626pub struct MemberBindStmt {627	pub(crate) syntax: SyntaxNode,628}629impl MemberBindStmt {630	pub fn obj_local(&self) -> Option<ObjLocal> {631		support::child(&self.syntax)632	}633}634635#[derive(Debug, Clone, PartialEq, Eq, Hash)]636pub struct MemberAssertStmt {637	pub(crate) syntax: SyntaxNode,638}639impl MemberAssertStmt {640	pub fn assertion(&self) -> Option<Assertion> {641		support::child(&self.syntax)642	}643}644645#[derive(Debug, Clone, PartialEq, Eq, Hash)]646pub struct MemberFieldNormal {647	pub(crate) syntax: SyntaxNode,648}649impl MemberFieldNormal {650	pub fn field_name(&self) -> Option<FieldName> {651		support::child(&self.syntax)652	}653	pub fn plus_token(&self) -> Option<SyntaxToken> {654		support::token(&self.syntax, T![+])655	}656	pub fn visibility(&self) -> Option<Visibility> {657		support::token_child(&self.syntax)658	}659	pub fn expr(&self) -> Option<Expr> {660		support::child(&self.syntax)661	}662}663664#[derive(Debug, Clone, PartialEq, Eq, Hash)]665pub struct MemberFieldMethod {666	pub(crate) syntax: SyntaxNode,667}668impl MemberFieldMethod {669	pub fn field_name(&self) -> Option<FieldName> {670		support::child(&self.syntax)671	}672	pub fn params_desc(&self) -> Option<ParamsDesc> {673		support::child(&self.syntax)674	}675	pub fn visibility(&self) -> Option<Visibility> {676		support::token_child(&self.syntax)677	}678	pub fn expr(&self) -> Option<Expr> {679		support::child(&self.syntax)680	}681}682683#[derive(Debug, Clone, PartialEq, Eq, Hash)]684pub struct FieldNameFixed {685	pub(crate) syntax: SyntaxNode,686}687impl FieldNameFixed {688	pub fn id(&self) -> Option<Name> {689		support::child(&self.syntax)690	}691	pub fn text(&self) -> Option<Text> {692		support::token_child(&self.syntax)693	}694}695696#[derive(Debug, Clone, PartialEq, Eq, Hash)]697pub struct FieldNameDynamic {698	pub(crate) syntax: SyntaxNode,699}700impl FieldNameDynamic {701	pub fn l_brack_token(&self) -> Option<SyntaxToken> {702		support::token(&self.syntax, T!['['])703	}704	pub fn expr(&self) -> Option<Expr> {705		support::child(&self.syntax)706	}707	pub fn r_brack_token(&self) -> Option<SyntaxToken> {708		support::token(&self.syntax, T![']'])709	}710}711712#[derive(Debug, Clone, PartialEq, Eq, Hash)]713pub struct ForSpec {714	pub(crate) syntax: SyntaxNode,715}716impl ForSpec {717	pub fn for_kw_token(&self) -> Option<SyntaxToken> {718		support::token(&self.syntax, T![for])719	}720	pub fn bind(&self) -> Option<Name> {721		support::child(&self.syntax)722	}723	pub fn in_kw_token(&self) -> Option<SyntaxToken> {724		support::token(&self.syntax, T![in])725	}726	pub fn expr(&self) -> Option<Expr> {727		support::child(&self.syntax)728	}729}730731#[derive(Debug, Clone, PartialEq, Eq, Hash)]732pub struct IfSpec {733	pub(crate) syntax: SyntaxNode,734}735impl IfSpec {736	pub fn if_kw_token(&self) -> Option<SyntaxToken> {737		support::token(&self.syntax, T![if])738	}739	pub fn expr(&self) -> Option<Expr> {740		support::child(&self.syntax)741	}742}743744#[derive(Debug, Clone, PartialEq, Eq, Hash)]745pub struct BindDestruct {746	pub(crate) syntax: SyntaxNode,747}748impl BindDestruct {749	pub fn into(&self) -> Option<Destruct> {750		support::child(&self.syntax)751	}752	pub fn assign_token(&self) -> Option<SyntaxToken> {753		support::token(&self.syntax, T![=])754	}755	pub fn value(&self) -> Option<Expr> {756		support::child(&self.syntax)757	}758}759760#[derive(Debug, Clone, PartialEq, Eq, Hash)]761pub struct BindFunction {762	pub(crate) syntax: SyntaxNode,763}764impl BindFunction {765	pub fn name(&self) -> Option<Name> {766		support::child(&self.syntax)767	}768	pub fn params(&self) -> Option<ParamsDesc> {769		support::child(&self.syntax)770	}771	pub fn assign_token(&self) -> Option<SyntaxToken> {772		support::token(&self.syntax, T![=])773	}774	pub fn value(&self) -> Option<Expr> {775		support::child(&self.syntax)776	}777}778779#[derive(Debug, Clone, PartialEq, Eq, Hash)]780pub struct Param {781	pub(crate) syntax: SyntaxNode,782}783impl Param {784	pub fn destruct(&self) -> Option<Destruct> {785		support::child(&self.syntax)786	}787	pub fn assign_token(&self) -> Option<SyntaxToken> {788		support::token(&self.syntax, T![=])789	}790	pub fn expr(&self) -> Option<Expr> {791		support::child(&self.syntax)792	}793}794795#[derive(Debug, Clone, PartialEq, Eq, Hash)]796pub struct DestructFull {797	pub(crate) syntax: SyntaxNode,798}799impl DestructFull {800	pub fn name(&self) -> Option<Name> {801		support::child(&self.syntax)802	}803}804805#[derive(Debug, Clone, PartialEq, Eq, Hash)]806pub struct DestructSkip {807	pub(crate) syntax: SyntaxNode,808}809impl DestructSkip {810	pub fn question_mark_token(&self) -> Option<SyntaxToken> {811		support::token(&self.syntax, T![?])812	}813}814815#[derive(Debug, Clone, PartialEq, Eq, Hash)]816pub struct DestructArray {817	pub(crate) syntax: SyntaxNode,818}819impl DestructArray {820	pub fn l_brack_token(&self) -> Option<SyntaxToken> {821		support::token(&self.syntax, T!['['])822	}823	pub fn destruct_array_parts(&self) -> AstChildren<DestructArrayPart> {824		support::children(&self.syntax)825	}826	pub fn r_brack_token(&self) -> Option<SyntaxToken> {827		support::token(&self.syntax, T![']'])828	}829}830831#[derive(Debug, Clone, PartialEq, Eq, Hash)]832pub struct DestructObject {833	pub(crate) syntax: SyntaxNode,834}835impl DestructObject {836	pub fn l_brace_token(&self) -> Option<SyntaxToken> {837		support::token(&self.syntax, T!['{'])838	}839	pub fn destruct_object_fields(&self) -> AstChildren<DestructObjectField> {840		support::children(&self.syntax)841	}842	pub fn destruct_rest(&self) -> Option<DestructRest> {843		support::child(&self.syntax)844	}845	pub fn comma_token(&self) -> Option<SyntaxToken> {846		support::token(&self.syntax, T![,])847	}848	pub fn r_brace_token(&self) -> Option<SyntaxToken> {849		support::token(&self.syntax, T!['}'])850	}851}852853#[derive(Debug, Clone, PartialEq, Eq, Hash)]854pub struct DestructObjectField {855	pub(crate) syntax: SyntaxNode,856}857impl DestructObjectField {858	pub fn field(&self) -> Option<Name> {859		support::child(&self.syntax)860	}861	pub fn colon_token(&self) -> Option<SyntaxToken> {862		support::token(&self.syntax, T![:])863	}864	pub fn destruct(&self) -> Option<Destruct> {865		support::child(&self.syntax)866	}867	pub fn assign_token(&self) -> Option<SyntaxToken> {868		support::token(&self.syntax, T![=])869	}870	pub fn expr(&self) -> Option<Expr> {871		support::child(&self.syntax)872	}873}874875#[derive(Debug, Clone, PartialEq, Eq, Hash)]876pub struct DestructRest {877	pub(crate) syntax: SyntaxNode,878}879impl DestructRest {880	pub fn dotdotdot_token(&self) -> Option<SyntaxToken> {881		support::token(&self.syntax, T![...])882	}883	pub fn into(&self) -> Option<Name> {884		support::child(&self.syntax)885	}886}887888#[derive(Debug, Clone, PartialEq, Eq, Hash)]889pub struct DestructArrayElement {890	pub(crate) syntax: SyntaxNode,891}892impl DestructArrayElement {893	pub fn destruct(&self) -> Option<Destruct> {894		support::child(&self.syntax)895	}896}897898#[derive(Debug, Clone, PartialEq, Eq, Hash)]899pub enum Expr {900	ExprBinary(ExprBinary),901	ExprUnary(ExprUnary),902	ExprSlice(ExprSlice),903	ExprIndex(ExprIndex),904	ExprIndexExpr(ExprIndexExpr),905	ExprApply(ExprApply),906	ExprObjExtend(ExprObjExtend),907	ExprParened(ExprParened),908	ExprIntrinsicThisFile(ExprIntrinsicThisFile),909	ExprIntrinsicId(ExprIntrinsicId),910	ExprIntrinsic(ExprIntrinsic),911	ExprString(ExprString),912	ExprNumber(ExprNumber),913	ExprLiteral(ExprLiteral),914	ExprArray(ExprArray),915	ExprObject(ExprObject),916	ExprArrayComp(ExprArrayComp),917	ExprImport(ExprImport),918	ExprVar(ExprVar),919	ExprLocal(ExprLocal),920	ExprIfThenElse(ExprIfThenElse),921	ExprFunction(ExprFunction),922	ExprAssert(ExprAssert),923	ExprError(ExprError),924}925926#[derive(Debug, Clone, PartialEq, Eq, Hash)]927pub enum ObjBody {928	ObjBodyComp(ObjBodyComp),929	ObjBodyMemberList(ObjBodyMemberList),930}931932#[derive(Debug, Clone, PartialEq, Eq, Hash)]933pub enum CompSpec {934	ForSpec(ForSpec),935	IfSpec(IfSpec),936}937938#[derive(Debug, Clone, PartialEq, Eq, Hash)]939pub enum Bind {940	BindDestruct(BindDestruct),941	BindFunction(BindFunction),942}943944#[derive(Debug, Clone, PartialEq, Eq, Hash)]945pub enum Member {946	MemberBindStmt(MemberBindStmt),947	MemberAssertStmt(MemberAssertStmt),948	MemberFieldNormal(MemberFieldNormal),949	MemberFieldMethod(MemberFieldMethod),950}951952#[derive(Debug, Clone, PartialEq, Eq, Hash)]953pub enum FieldName {954	FieldNameFixed(FieldNameFixed),955	FieldNameDynamic(FieldNameDynamic),956}957958#[derive(Debug, Clone, PartialEq, Eq, Hash)]959pub enum Destruct {960	DestructFull(DestructFull),961	DestructSkip(DestructSkip),962	DestructArray(DestructArray),963	DestructObject(DestructObject),964}965966#[derive(Debug, Clone, PartialEq, Eq, Hash)]967pub enum DestructArrayPart {968	DestructArrayElement(DestructArrayElement),969	DestructRest(DestructRest),970}971972#[derive(Debug, Clone, PartialEq, Eq, Hash)]973pub struct BinaryOperator {974	syntax: SyntaxToken,975	kind: BinaryOperatorKind,976}977978#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]979pub enum BinaryOperatorKind {980	Or,981	And,982	BitOr,983	BitXor,984	BitAnd,985	Eq,986	Ne,987	Lt,988	Gt,989	Le,990	Ge,991	InKw,992	Lhs,993	Rhs,994	Plus,995	Minus,996	Mul,997	Div,998	Modulo,999	MetaObjectApply,1000	ErrorNoOperator,1001}10021003#[derive(Debug, Clone, PartialEq, Eq, Hash)]1004pub struct UnaryOperator {1005	syntax: SyntaxToken,1006	kind: UnaryOperatorKind,1007}10081009#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]1010pub enum UnaryOperatorKind {1011	Minus,1012	Not,1013	BitNot,1014}10151016#[derive(Debug, Clone, PartialEq, Eq, Hash)]1017pub struct Literal {1018	syntax: SyntaxToken,1019	kind: LiteralKind,1020}10211022#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]1023pub enum LiteralKind {1024	NullKw,1025	TrueKw,1026	FalseKw,1027	SelfKw,1028	Dollar,1029	SuperKw,1030}10311032#[derive(Debug, Clone, PartialEq, Eq, Hash)]1033pub struct Text {1034	syntax: SyntaxToken,1035	kind: TextKind,1036}10371038#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]1039pub enum TextKind {1040	StringDouble,1041	ErrorStringDoubleUnterminated,1042	StringSingle,1043	ErrorStringSingleUnterminated,1044	StringDoubleVerbatim,1045	ErrorStringDoubleVerbatimUnterminated,1046	StringSingleVerbatim,1047	ErrorStringSingleVerbatimUnterminated,1048	ErrorStringVerbatimMissingQuotes,1049	StringBlock,1050	ErrorStringBlockUnexpectedEnd,1051	ErrorStringBlockMissingNewLine,1052	ErrorStringBlockMissingTermination,1053	ErrorStringBlockMissingIndent,1054}10551056#[derive(Debug, Clone, PartialEq, Eq, Hash)]1057pub struct Number {1058	syntax: SyntaxToken,1059	kind: NumberKind,1060}10611062#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]1063pub enum NumberKind {1064	Float,1065	ErrorFloatJunkAfterPoint,1066	ErrorFloatJunkAfterExponent,1067	ErrorFloatJunkAfterExponentSign,1068}10691070#[derive(Debug, Clone, PartialEq, Eq, Hash)]1071pub struct ImportKind {1072	syntax: SyntaxToken,1073	kind: ImportKindKind,1074}10751076#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]1077pub enum ImportKindKind {1078	ImportstrKw,1079	ImportbinKw,1080	ImportKw,1081}10821083#[derive(Debug, Clone, PartialEq, Eq, Hash)]1084pub struct Visibility {1085	syntax: SyntaxToken,1086	kind: VisibilityKind,1087}10881089#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]1090pub enum VisibilityKind {1091	Coloncoloncolon,1092	Coloncolon,1093	Colon,1094}10951096#[derive(Debug, Clone, PartialEq, Eq, Hash)]1097pub struct Trivia {1098	syntax: SyntaxToken,1099	kind: TriviaKind,1100}11011102#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]1103pub enum TriviaKind {1104	Whitespace,1105	MultiLineComment,1106	ErrorCommentTooShort,1107	ErrorCommentUnterminated,1108	SingleLineHashComment,1109	SingleLineSlashComment,1110}11111112#[derive(Debug, Clone, PartialEq, Eq, Hash)]1113pub struct ParsingError {1114	syntax: SyntaxToken,1115	kind: ParsingErrorKind,1116}11171118#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]1119pub enum ParsingErrorKind {1120	ErrorMissingToken,1121	ErrorUnexpectedToken,1122	ErrorCustom,1123}1124impl AstNode for SourceFile {1125	fn can_cast(kind: SyntaxKind) -> bool {1126		kind == SOURCE_FILE1127	}1128	fn cast(syntax: SyntaxNode) -> Option<Self> {1129		if Self::can_cast(syntax.kind()) {1130			Some(Self { syntax })1131		} else {1132			None1133		}1134	}1135	fn syntax(&self) -> &SyntaxNode {1136		&self.syntax1137	}1138}1139impl AstNode for ExprBinary {1140	fn can_cast(kind: SyntaxKind) -> bool {1141		kind == EXPR_BINARY1142	}1143	fn cast(syntax: SyntaxNode) -> Option<Self> {1144		if Self::can_cast(syntax.kind()) {1145			Some(Self { syntax })1146		} else {1147			None1148		}1149	}1150	fn syntax(&self) -> &SyntaxNode {1151		&self.syntax1152	}1153}1154impl AstNode for LhsExpr {1155	fn can_cast(kind: SyntaxKind) -> bool {1156		kind == LHS_EXPR1157	}1158	fn cast(syntax: SyntaxNode) -> Option<Self> {1159		if Self::can_cast(syntax.kind()) {1160			Some(Self { syntax })1161		} else {1162			None1163		}1164	}1165	fn syntax(&self) -> &SyntaxNode {1166		&self.syntax1167	}1168}1169impl AstNode for ExprUnary {1170	fn can_cast(kind: SyntaxKind) -> bool {1171		kind == EXPR_UNARY1172	}1173	fn cast(syntax: SyntaxNode) -> Option<Self> {1174		if Self::can_cast(syntax.kind()) {1175			Some(Self { syntax })1176		} else {1177			None1178		}1179	}1180	fn syntax(&self) -> &SyntaxNode {1181		&self.syntax1182	}1183}1184impl AstNode for ExprSlice {1185	fn can_cast(kind: SyntaxKind) -> bool {1186		kind == EXPR_SLICE1187	}1188	fn cast(syntax: SyntaxNode) -> Option<Self> {1189		if Self::can_cast(syntax.kind()) {1190			Some(Self { syntax })1191		} else {1192			None1193		}1194	}1195	fn syntax(&self) -> &SyntaxNode {1196		&self.syntax1197	}1198}1199impl AstNode for SliceDesc {1200	fn can_cast(kind: SyntaxKind) -> bool {1201		kind == SLICE_DESC1202	}1203	fn cast(syntax: SyntaxNode) -> Option<Self> {1204		if Self::can_cast(syntax.kind()) {1205			Some(Self { syntax })1206		} else {1207			None1208		}1209	}1210	fn syntax(&self) -> &SyntaxNode {1211		&self.syntax1212	}1213}1214impl AstNode for ExprIndex {1215	fn can_cast(kind: SyntaxKind) -> bool {1216		kind == EXPR_INDEX1217	}1218	fn cast(syntax: SyntaxNode) -> Option<Self> {1219		if Self::can_cast(syntax.kind()) {1220			Some(Self { syntax })1221		} else {1222			None1223		}1224	}1225	fn syntax(&self) -> &SyntaxNode {1226		&self.syntax1227	}1228}1229impl AstNode for Name {1230	fn can_cast(kind: SyntaxKind) -> bool {1231		kind == NAME1232	}1233	fn cast(syntax: SyntaxNode) -> Option<Self> {1234		if Self::can_cast(syntax.kind()) {1235			Some(Self { syntax })1236		} else {1237			None1238		}1239	}1240	fn syntax(&self) -> &SyntaxNode {1241		&self.syntax1242	}1243}1244impl AstNode for ExprIndexExpr {1245	fn can_cast(kind: SyntaxKind) -> bool {1246		kind == EXPR_INDEX_EXPR1247	}1248	fn cast(syntax: SyntaxNode) -> Option<Self> {1249		if Self::can_cast(syntax.kind()) {1250			Some(Self { syntax })1251		} else {1252			None1253		}1254	}1255	fn syntax(&self) -> &SyntaxNode {1256		&self.syntax1257	}1258}1259impl AstNode for ExprApply {1260	fn can_cast(kind: SyntaxKind) -> bool {1261		kind == EXPR_APPLY1262	}1263	fn cast(syntax: SyntaxNode) -> Option<Self> {1264		if Self::can_cast(syntax.kind()) {1265			Some(Self { syntax })1266		} else {1267			None1268		}1269	}1270	fn syntax(&self) -> &SyntaxNode {1271		&self.syntax1272	}1273}1274impl AstNode for ArgsDesc {1275	fn can_cast(kind: SyntaxKind) -> bool {1276		kind == ARGS_DESC1277	}1278	fn cast(syntax: SyntaxNode) -> Option<Self> {1279		if Self::can_cast(syntax.kind()) {1280			Some(Self { syntax })1281		} else {1282			None1283		}1284	}1285	fn syntax(&self) -> &SyntaxNode {1286		&self.syntax1287	}1288}1289impl AstNode for ExprObjExtend {1290	fn can_cast(kind: SyntaxKind) -> bool {1291		kind == EXPR_OBJ_EXTEND1292	}1293	fn cast(syntax: SyntaxNode) -> Option<Self> {1294		if Self::can_cast(syntax.kind()) {1295			Some(Self { syntax })1296		} else {1297			None1298		}1299	}1300	fn syntax(&self) -> &SyntaxNode {1301		&self.syntax1302	}1303}1304impl AstNode for ExprParened {1305	fn can_cast(kind: SyntaxKind) -> bool {1306		kind == EXPR_PARENED1307	}1308	fn cast(syntax: SyntaxNode) -> Option<Self> {1309		if Self::can_cast(syntax.kind()) {1310			Some(Self { syntax })1311		} else {1312			None1313		}1314	}1315	fn syntax(&self) -> &SyntaxNode {1316		&self.syntax1317	}1318}1319impl AstNode for ExprLiteral {1320	fn can_cast(kind: SyntaxKind) -> bool {1321		kind == EXPR_LITERAL1322	}1323	fn cast(syntax: SyntaxNode) -> Option<Self> {1324		if Self::can_cast(syntax.kind()) {1325			Some(Self { syntax })1326		} else {1327			None1328		}1329	}1330	fn syntax(&self) -> &SyntaxNode {1331		&self.syntax1332	}1333}1334impl AstNode for ExprIntrinsicThisFile {1335	fn can_cast(kind: SyntaxKind) -> bool {1336		kind == EXPR_INTRINSIC_THIS_FILE1337	}1338	fn cast(syntax: SyntaxNode) -> Option<Self> {1339		if Self::can_cast(syntax.kind()) {1340			Some(Self { syntax })1341		} else {1342			None1343		}1344	}1345	fn syntax(&self) -> &SyntaxNode {1346		&self.syntax1347	}1348}1349impl AstNode for ExprIntrinsicId {1350	fn can_cast(kind: SyntaxKind) -> bool {1351		kind == EXPR_INTRINSIC_ID1352	}1353	fn cast(syntax: SyntaxNode) -> Option<Self> {1354		if Self::can_cast(syntax.kind()) {1355			Some(Self { syntax })1356		} else {1357			None1358		}1359	}1360	fn syntax(&self) -> &SyntaxNode {1361		&self.syntax1362	}1363}1364impl AstNode for ExprIntrinsic {1365	fn can_cast(kind: SyntaxKind) -> bool {1366		kind == EXPR_INTRINSIC1367	}1368	fn cast(syntax: SyntaxNode) -> Option<Self> {1369		if Self::can_cast(syntax.kind()) {1370			Some(Self { syntax })1371		} else {1372			None1373		}1374	}1375	fn syntax(&self) -> &SyntaxNode {1376		&self.syntax1377	}1378}1379impl AstNode for ExprString {1380	fn can_cast(kind: SyntaxKind) -> bool {1381		kind == EXPR_STRING1382	}1383	fn cast(syntax: SyntaxNode) -> Option<Self> {1384		if Self::can_cast(syntax.kind()) {1385			Some(Self { syntax })1386		} else {1387			None1388		}1389	}1390	fn syntax(&self) -> &SyntaxNode {1391		&self.syntax1392	}1393}1394impl AstNode for ExprNumber {1395	fn can_cast(kind: SyntaxKind) -> bool {1396		kind == EXPR_NUMBER1397	}1398	fn cast(syntax: SyntaxNode) -> Option<Self> {1399		if Self::can_cast(syntax.kind()) {1400			Some(Self { syntax })1401		} else {1402			None1403		}1404	}1405	fn syntax(&self) -> &SyntaxNode {1406		&self.syntax1407	}1408}1409impl AstNode for ExprArray {1410	fn can_cast(kind: SyntaxKind) -> bool {1411		kind == EXPR_ARRAY1412	}1413	fn cast(syntax: SyntaxNode) -> Option<Self> {1414		if Self::can_cast(syntax.kind()) {1415			Some(Self { syntax })1416		} else {1417			None1418		}1419	}1420	fn syntax(&self) -> &SyntaxNode {1421		&self.syntax1422	}1423}1424impl AstNode for ExprObject {1425	fn can_cast(kind: SyntaxKind) -> bool {1426		kind == EXPR_OBJECT1427	}1428	fn cast(syntax: SyntaxNode) -> Option<Self> {1429		if Self::can_cast(syntax.kind()) {1430			Some(Self { syntax })1431		} else {1432			None1433		}1434	}1435	fn syntax(&self) -> &SyntaxNode {1436		&self.syntax1437	}1438}1439impl AstNode for ExprArrayComp {1440	fn can_cast(kind: SyntaxKind) -> bool {1441		kind == EXPR_ARRAY_COMP1442	}1443	fn cast(syntax: SyntaxNode) -> Option<Self> {1444		if Self::can_cast(syntax.kind()) {1445			Some(Self { syntax })1446		} else {1447			None1448		}1449	}1450	fn syntax(&self) -> &SyntaxNode {1451		&self.syntax1452	}1453}1454impl AstNode for ExprImport {1455	fn can_cast(kind: SyntaxKind) -> bool {1456		kind == EXPR_IMPORT1457	}1458	fn cast(syntax: SyntaxNode) -> Option<Self> {1459		if Self::can_cast(syntax.kind()) {1460			Some(Self { syntax })1461		} else {1462			None1463		}1464	}1465	fn syntax(&self) -> &SyntaxNode {1466		&self.syntax1467	}1468}1469impl AstNode for ExprVar {1470	fn can_cast(kind: SyntaxKind) -> bool {1471		kind == EXPR_VAR1472	}1473	fn cast(syntax: SyntaxNode) -> Option<Self> {1474		if Self::can_cast(syntax.kind()) {1475			Some(Self { syntax })1476		} else {1477			None1478		}1479	}1480	fn syntax(&self) -> &SyntaxNode {1481		&self.syntax1482	}1483}1484impl AstNode for ExprLocal {1485	fn can_cast(kind: SyntaxKind) -> bool {1486		kind == EXPR_LOCAL1487	}1488	fn cast(syntax: SyntaxNode) -> Option<Self> {1489		if Self::can_cast(syntax.kind()) {1490			Some(Self { syntax })1491		} else {1492			None1493		}1494	}1495	fn syntax(&self) -> &SyntaxNode {1496		&self.syntax1497	}1498}1499impl AstNode for ExprIfThenElse {1500	fn can_cast(kind: SyntaxKind) -> bool {1501		kind == EXPR_IF_THEN_ELSE1502	}1503	fn cast(syntax: SyntaxNode) -> Option<Self> {1504		if Self::can_cast(syntax.kind()) {1505			Some(Self { syntax })1506		} else {1507			None1508		}1509	}1510	fn syntax(&self) -> &SyntaxNode {1511		&self.syntax1512	}1513}1514impl AstNode for TrueExpr {1515	fn can_cast(kind: SyntaxKind) -> bool {1516		kind == TRUE_EXPR1517	}1518	fn cast(syntax: SyntaxNode) -> Option<Self> {1519		if Self::can_cast(syntax.kind()) {1520			Some(Self { syntax })1521		} else {1522			None1523		}1524	}1525	fn syntax(&self) -> &SyntaxNode {1526		&self.syntax1527	}1528}1529impl AstNode for FalseExpr {1530	fn can_cast(kind: SyntaxKind) -> bool {1531		kind == FALSE_EXPR1532	}1533	fn cast(syntax: SyntaxNode) -> Option<Self> {1534		if Self::can_cast(syntax.kind()) {1535			Some(Self { syntax })1536		} else {1537			None1538		}1539	}1540	fn syntax(&self) -> &SyntaxNode {1541		&self.syntax1542	}1543}1544impl AstNode for ExprFunction {1545	fn can_cast(kind: SyntaxKind) -> bool {1546		kind == EXPR_FUNCTION1547	}1548	fn cast(syntax: SyntaxNode) -> Option<Self> {1549		if Self::can_cast(syntax.kind()) {1550			Some(Self { syntax })1551		} else {1552			None1553		}1554	}1555	fn syntax(&self) -> &SyntaxNode {1556		&self.syntax1557	}1558}1559impl AstNode for ParamsDesc {1560	fn can_cast(kind: SyntaxKind) -> bool {1561		kind == PARAMS_DESC1562	}1563	fn cast(syntax: SyntaxNode) -> Option<Self> {1564		if Self::can_cast(syntax.kind()) {1565			Some(Self { syntax })1566		} else {1567			None1568		}1569	}1570	fn syntax(&self) -> &SyntaxNode {1571		&self.syntax1572	}1573}1574impl AstNode for ExprAssert {1575	fn can_cast(kind: SyntaxKind) -> bool {1576		kind == EXPR_ASSERT1577	}1578	fn cast(syntax: SyntaxNode) -> Option<Self> {1579		if Self::can_cast(syntax.kind()) {1580			Some(Self { syntax })1581		} else {1582			None1583		}1584	}1585	fn syntax(&self) -> &SyntaxNode {1586		&self.syntax1587	}1588}1589impl AstNode for Assertion {1590	fn can_cast(kind: SyntaxKind) -> bool {1591		kind == ASSERTION1592	}1593	fn cast(syntax: SyntaxNode) -> Option<Self> {1594		if Self::can_cast(syntax.kind()) {1595			Some(Self { syntax })1596		} else {1597			None1598		}1599	}1600	fn syntax(&self) -> &SyntaxNode {1601		&self.syntax1602	}1603}1604impl AstNode for ExprError {1605	fn can_cast(kind: SyntaxKind) -> bool {1606		kind == EXPR_ERROR1607	}1608	fn cast(syntax: SyntaxNode) -> Option<Self> {1609		if Self::can_cast(syntax.kind()) {1610			Some(Self { syntax })1611		} else {1612			None1613		}1614	}1615	fn syntax(&self) -> &SyntaxNode {1616		&self.syntax1617	}1618}1619impl AstNode for SliceDescEnd {1620	fn can_cast(kind: SyntaxKind) -> bool {1621		kind == SLICE_DESC_END1622	}1623	fn cast(syntax: SyntaxNode) -> Option<Self> {1624		if Self::can_cast(syntax.kind()) {1625			Some(Self { syntax })1626		} else {1627			None1628		}1629	}1630	fn syntax(&self) -> &SyntaxNode {1631		&self.syntax1632	}1633}1634impl AstNode for SliceDescStep {1635	fn can_cast(kind: SyntaxKind) -> bool {1636		kind == SLICE_DESC_STEP1637	}1638	fn cast(syntax: SyntaxNode) -> Option<Self> {1639		if Self::can_cast(syntax.kind()) {1640			Some(Self { syntax })1641		} else {1642			None1643		}1644	}1645	fn syntax(&self) -> &SyntaxNode {1646		&self.syntax1647	}1648}1649impl AstNode for Arg {1650	fn can_cast(kind: SyntaxKind) -> bool {1651		kind == ARG1652	}1653	fn cast(syntax: SyntaxNode) -> Option<Self> {1654		if Self::can_cast(syntax.kind()) {1655			Some(Self { syntax })1656		} else {1657			None1658		}1659	}1660	fn syntax(&self) -> &SyntaxNode {1661		&self.syntax1662	}1663}1664impl AstNode for ObjBodyComp {1665	fn can_cast(kind: SyntaxKind) -> bool {1666		kind == OBJ_BODY_COMP1667	}1668	fn cast(syntax: SyntaxNode) -> Option<Self> {1669		if Self::can_cast(syntax.kind()) {1670			Some(Self { syntax })1671		} else {1672			None1673		}1674	}1675	fn syntax(&self) -> &SyntaxNode {1676		&self.syntax1677	}1678}1679impl AstNode for ObjLocalPostComma {1680	fn can_cast(kind: SyntaxKind) -> bool {1681		kind == OBJ_LOCAL_POST_COMMA1682	}1683	fn cast(syntax: SyntaxNode) -> Option<Self> {1684		if Self::can_cast(syntax.kind()) {1685			Some(Self { syntax })1686		} else {1687			None1688		}1689	}1690	fn syntax(&self) -> &SyntaxNode {1691		&self.syntax1692	}1693}1694impl AstNode for ObjLocalPreComma {1695	fn can_cast(kind: SyntaxKind) -> bool {1696		kind == OBJ_LOCAL_PRE_COMMA1697	}1698	fn cast(syntax: SyntaxNode) -> Option<Self> {1699		if Self::can_cast(syntax.kind()) {1700			Some(Self { syntax })1701		} else {1702			None1703		}1704	}1705	fn syntax(&self) -> &SyntaxNode {1706		&self.syntax1707	}1708}1709impl AstNode for ObjBodyMemberList {1710	fn can_cast(kind: SyntaxKind) -> bool {1711		kind == OBJ_BODY_MEMBER_LIST1712	}1713	fn cast(syntax: SyntaxNode) -> Option<Self> {1714		if Self::can_cast(syntax.kind()) {1715			Some(Self { syntax })1716		} else {1717			None1718		}1719	}1720	fn syntax(&self) -> &SyntaxNode {1721		&self.syntax1722	}1723}1724impl AstNode for ObjLocal {1725	fn can_cast(kind: SyntaxKind) -> bool {1726		kind == OBJ_LOCAL1727	}1728	fn cast(syntax: SyntaxNode) -> Option<Self> {1729		if Self::can_cast(syntax.kind()) {1730			Some(Self { syntax })1731		} else {1732			None1733		}1734	}1735	fn syntax(&self) -> &SyntaxNode {1736		&self.syntax1737	}1738}1739impl AstNode for MemberBindStmt {1740	fn can_cast(kind: SyntaxKind) -> bool {1741		kind == MEMBER_BIND_STMT1742	}1743	fn cast(syntax: SyntaxNode) -> Option<Self> {1744		if Self::can_cast(syntax.kind()) {1745			Some(Self { syntax })1746		} else {1747			None1748		}1749	}1750	fn syntax(&self) -> &SyntaxNode {1751		&self.syntax1752	}1753}1754impl AstNode for MemberAssertStmt {1755	fn can_cast(kind: SyntaxKind) -> bool {1756		kind == MEMBER_ASSERT_STMT1757	}1758	fn cast(syntax: SyntaxNode) -> Option<Self> {1759		if Self::can_cast(syntax.kind()) {1760			Some(Self { syntax })1761		} else {1762			None1763		}1764	}1765	fn syntax(&self) -> &SyntaxNode {1766		&self.syntax1767	}1768}1769impl AstNode for MemberFieldNormal {1770	fn can_cast(kind: SyntaxKind) -> bool {1771		kind == MEMBER_FIELD_NORMAL1772	}1773	fn cast(syntax: SyntaxNode) -> Option<Self> {1774		if Self::can_cast(syntax.kind()) {1775			Some(Self { syntax })1776		} else {1777			None1778		}1779	}1780	fn syntax(&self) -> &SyntaxNode {1781		&self.syntax1782	}1783}1784impl AstNode for MemberFieldMethod {1785	fn can_cast(kind: SyntaxKind) -> bool {1786		kind == MEMBER_FIELD_METHOD1787	}1788	fn cast(syntax: SyntaxNode) -> Option<Self> {1789		if Self::can_cast(syntax.kind()) {1790			Some(Self { syntax })1791		} else {1792			None1793		}1794	}1795	fn syntax(&self) -> &SyntaxNode {1796		&self.syntax1797	}1798}1799impl AstNode for FieldNameFixed {1800	fn can_cast(kind: SyntaxKind) -> bool {1801		kind == FIELD_NAME_FIXED1802	}1803	fn cast(syntax: SyntaxNode) -> Option<Self> {1804		if Self::can_cast(syntax.kind()) {1805			Some(Self { syntax })1806		} else {1807			None1808		}1809	}1810	fn syntax(&self) -> &SyntaxNode {1811		&self.syntax1812	}1813}1814impl AstNode for FieldNameDynamic {1815	fn can_cast(kind: SyntaxKind) -> bool {1816		kind == FIELD_NAME_DYNAMIC1817	}1818	fn cast(syntax: SyntaxNode) -> Option<Self> {1819		if Self::can_cast(syntax.kind()) {1820			Some(Self { syntax })1821		} else {1822			None1823		}1824	}1825	fn syntax(&self) -> &SyntaxNode {1826		&self.syntax1827	}1828}1829impl AstNode for ForSpec {1830	fn can_cast(kind: SyntaxKind) -> bool {1831		kind == FOR_SPEC1832	}1833	fn cast(syntax: SyntaxNode) -> Option<Self> {1834		if Self::can_cast(syntax.kind()) {1835			Some(Self { syntax })1836		} else {1837			None1838		}1839	}1840	fn syntax(&self) -> &SyntaxNode {1841		&self.syntax1842	}1843}1844impl AstNode for IfSpec {1845	fn can_cast(kind: SyntaxKind) -> bool {1846		kind == IF_SPEC1847	}1848	fn cast(syntax: SyntaxNode) -> Option<Self> {1849		if Self::can_cast(syntax.kind()) {1850			Some(Self { syntax })1851		} else {1852			None1853		}1854	}1855	fn syntax(&self) -> &SyntaxNode {1856		&self.syntax1857	}1858}1859impl AstNode for BindDestruct {1860	fn can_cast(kind: SyntaxKind) -> bool {1861		kind == BIND_DESTRUCT1862	}1863	fn cast(syntax: SyntaxNode) -> Option<Self> {1864		if Self::can_cast(syntax.kind()) {1865			Some(Self { syntax })1866		} else {1867			None1868		}1869	}1870	fn syntax(&self) -> &SyntaxNode {1871		&self.syntax1872	}1873}1874impl AstNode for BindFunction {1875	fn can_cast(kind: SyntaxKind) -> bool {1876		kind == BIND_FUNCTION1877	}1878	fn cast(syntax: SyntaxNode) -> Option<Self> {1879		if Self::can_cast(syntax.kind()) {1880			Some(Self { syntax })1881		} else {1882			None1883		}1884	}1885	fn syntax(&self) -> &SyntaxNode {1886		&self.syntax1887	}1888}1889impl AstNode for Param {1890	fn can_cast(kind: SyntaxKind) -> bool {1891		kind == PARAM1892	}1893	fn cast(syntax: SyntaxNode) -> Option<Self> {1894		if Self::can_cast(syntax.kind()) {1895			Some(Self { syntax })1896		} else {1897			None1898		}1899	}1900	fn syntax(&self) -> &SyntaxNode {1901		&self.syntax1902	}1903}1904impl AstNode for DestructFull {1905	fn can_cast(kind: SyntaxKind) -> bool {1906		kind == DESTRUCT_FULL1907	}1908	fn cast(syntax: SyntaxNode) -> Option<Self> {1909		if Self::can_cast(syntax.kind()) {1910			Some(Self { syntax })1911		} else {1912			None1913		}1914	}1915	fn syntax(&self) -> &SyntaxNode {1916		&self.syntax1917	}1918}1919impl AstNode for DestructSkip {1920	fn can_cast(kind: SyntaxKind) -> bool {1921		kind == DESTRUCT_SKIP1922	}1923	fn cast(syntax: SyntaxNode) -> Option<Self> {1924		if Self::can_cast(syntax.kind()) {1925			Some(Self { syntax })1926		} else {1927			None1928		}1929	}1930	fn syntax(&self) -> &SyntaxNode {1931		&self.syntax1932	}1933}1934impl AstNode for DestructArray {1935	fn can_cast(kind: SyntaxKind) -> bool {1936		kind == DESTRUCT_ARRAY1937	}1938	fn cast(syntax: SyntaxNode) -> Option<Self> {1939		if Self::can_cast(syntax.kind()) {1940			Some(Self { syntax })1941		} else {1942			None1943		}1944	}1945	fn syntax(&self) -> &SyntaxNode {1946		&self.syntax1947	}1948}1949impl AstNode for DestructObject {1950	fn can_cast(kind: SyntaxKind) -> bool {1951		kind == DESTRUCT_OBJECT1952	}1953	fn cast(syntax: SyntaxNode) -> Option<Self> {1954		if Self::can_cast(syntax.kind()) {1955			Some(Self { syntax })1956		} else {1957			None1958		}1959	}1960	fn syntax(&self) -> &SyntaxNode {1961		&self.syntax1962	}1963}1964impl AstNode for DestructObjectField {1965	fn can_cast(kind: SyntaxKind) -> bool {1966		kind == DESTRUCT_OBJECT_FIELD1967	}1968	fn cast(syntax: SyntaxNode) -> Option<Self> {1969		if Self::can_cast(syntax.kind()) {1970			Some(Self { syntax })1971		} else {1972			None1973		}1974	}1975	fn syntax(&self) -> &SyntaxNode {1976		&self.syntax1977	}1978}1979impl AstNode for DestructRest {1980	fn can_cast(kind: SyntaxKind) -> bool {1981		kind == DESTRUCT_REST1982	}1983	fn cast(syntax: SyntaxNode) -> Option<Self> {1984		if Self::can_cast(syntax.kind()) {1985			Some(Self { syntax })1986		} else {1987			None1988		}1989	}1990	fn syntax(&self) -> &SyntaxNode {1991		&self.syntax1992	}1993}1994impl AstNode for DestructArrayElement {1995	fn can_cast(kind: SyntaxKind) -> bool {1996		kind == DESTRUCT_ARRAY_ELEMENT1997	}1998	fn cast(syntax: SyntaxNode) -> Option<Self> {1999		if Self::can_cast(syntax.kind()) {2000			Some(Self { syntax })2001		} else {2002			None2003		}2004	}2005	fn syntax(&self) -> &SyntaxNode {2006		&self.syntax2007	}2008}2009impl From<ExprBinary> for Expr {2010	fn from(node: ExprBinary) -> Expr {2011		Expr::ExprBinary(node)2012	}2013}2014impl From<ExprUnary> for Expr {2015	fn from(node: ExprUnary) -> Expr {2016		Expr::ExprUnary(node)2017	}2018}2019impl From<ExprSlice> for Expr {2020	fn from(node: ExprSlice) -> Expr {2021		Expr::ExprSlice(node)2022	}2023}2024impl From<ExprIndex> for Expr {2025	fn from(node: ExprIndex) -> Expr {2026		Expr::ExprIndex(node)2027	}2028}2029impl From<ExprIndexExpr> for Expr {2030	fn from(node: ExprIndexExpr) -> Expr {2031		Expr::ExprIndexExpr(node)2032	}2033}2034impl From<ExprApply> for Expr {2035	fn from(node: ExprApply) -> Expr {2036		Expr::ExprApply(node)2037	}2038}2039impl From<ExprObjExtend> for Expr {2040	fn from(node: ExprObjExtend) -> Expr {2041		Expr::ExprObjExtend(node)2042	}2043}2044impl From<ExprParened> for Expr {2045	fn from(node: ExprParened) -> Expr {2046		Expr::ExprParened(node)2047	}2048}2049impl From<ExprIntrinsicThisFile> for Expr {2050	fn from(node: ExprIntrinsicThisFile) -> Expr {2051		Expr::ExprIntrinsicThisFile(node)2052	}2053}2054impl From<ExprIntrinsicId> for Expr {2055	fn from(node: ExprIntrinsicId) -> Expr {2056		Expr::ExprIntrinsicId(node)2057	}2058}2059impl From<ExprIntrinsic> for Expr {2060	fn from(node: ExprIntrinsic) -> Expr {2061		Expr::ExprIntrinsic(node)2062	}2063}2064impl From<ExprString> for Expr {2065	fn from(node: ExprString) -> Expr {2066		Expr::ExprString(node)2067	}2068}2069impl From<ExprNumber> for Expr {2070	fn from(node: ExprNumber) -> Expr {2071		Expr::ExprNumber(node)2072	}2073}2074impl From<ExprLiteral> for Expr {2075	fn from(node: ExprLiteral) -> Expr {2076		Expr::ExprLiteral(node)2077	}2078}2079impl From<ExprArray> for Expr {2080	fn from(node: ExprArray) -> Expr {2081		Expr::ExprArray(node)2082	}2083}2084impl From<ExprObject> for Expr {2085	fn from(node: ExprObject) -> Expr {2086		Expr::ExprObject(node)2087	}2088}2089impl From<ExprArrayComp> for Expr {2090	fn from(node: ExprArrayComp) -> Expr {2091		Expr::ExprArrayComp(node)2092	}2093}2094impl From<ExprImport> for Expr {2095	fn from(node: ExprImport) -> Expr {2096		Expr::ExprImport(node)2097	}2098}2099impl From<ExprVar> for Expr {2100	fn from(node: ExprVar) -> Expr {2101		Expr::ExprVar(node)2102	}2103}2104impl From<ExprLocal> for Expr {2105	fn from(node: ExprLocal) -> Expr {2106		Expr::ExprLocal(node)2107	}2108}2109impl From<ExprIfThenElse> for Expr {2110	fn from(node: ExprIfThenElse) -> Expr {2111		Expr::ExprIfThenElse(node)2112	}2113}2114impl From<ExprFunction> for Expr {2115	fn from(node: ExprFunction) -> Expr {2116		Expr::ExprFunction(node)2117	}2118}2119impl From<ExprAssert> for Expr {2120	fn from(node: ExprAssert) -> Expr {2121		Expr::ExprAssert(node)2122	}2123}2124impl From<ExprError> for Expr {2125	fn from(node: ExprError) -> Expr {2126		Expr::ExprError(node)2127	}2128}2129impl AstNode for Expr {2130	fn can_cast(kind: SyntaxKind) -> bool {2131		match kind {2132			EXPR_BINARY2133			| EXPR_UNARY2134			| EXPR_SLICE2135			| EXPR_INDEX2136			| EXPR_INDEX_EXPR2137			| EXPR_APPLY2138			| EXPR_OBJ_EXTEND2139			| EXPR_PARENED2140			| EXPR_INTRINSIC_THIS_FILE2141			| EXPR_INTRINSIC_ID2142			| EXPR_INTRINSIC2143			| EXPR_STRING2144			| EXPR_NUMBER2145			| EXPR_LITERAL2146			| EXPR_ARRAY2147			| EXPR_OBJECT2148			| EXPR_ARRAY_COMP2149			| EXPR_IMPORT2150			| EXPR_VAR2151			| EXPR_LOCAL2152			| EXPR_IF_THEN_ELSE2153			| EXPR_FUNCTION2154			| EXPR_ASSERT2155			| EXPR_ERROR => true,2156			_ => false,2157		}2158	}2159	fn cast(syntax: SyntaxNode) -> Option<Self> {2160		let res = match syntax.kind() {2161			EXPR_BINARY => Expr::ExprBinary(ExprBinary { syntax }),2162			EXPR_UNARY => Expr::ExprUnary(ExprUnary { syntax }),2163			EXPR_SLICE => Expr::ExprSlice(ExprSlice { syntax }),2164			EXPR_INDEX => Expr::ExprIndex(ExprIndex { syntax }),2165			EXPR_INDEX_EXPR => Expr::ExprIndexExpr(ExprIndexExpr { syntax }),2166			EXPR_APPLY => Expr::ExprApply(ExprApply { syntax }),2167			EXPR_OBJ_EXTEND => Expr::ExprObjExtend(ExprObjExtend { syntax }),2168			EXPR_PARENED => Expr::ExprParened(ExprParened { syntax }),2169			EXPR_INTRINSIC_THIS_FILE => {2170				Expr::ExprIntrinsicThisFile(ExprIntrinsicThisFile { syntax })2171			}2172			EXPR_INTRINSIC_ID => Expr::ExprIntrinsicId(ExprIntrinsicId { syntax }),2173			EXPR_INTRINSIC => Expr::ExprIntrinsic(ExprIntrinsic { syntax }),2174			EXPR_STRING => Expr::ExprString(ExprString { syntax }),2175			EXPR_NUMBER => Expr::ExprNumber(ExprNumber { syntax }),2176			EXPR_LITERAL => Expr::ExprLiteral(ExprLiteral { syntax }),2177			EXPR_ARRAY => Expr::ExprArray(ExprArray { syntax }),2178			EXPR_OBJECT => Expr::ExprObject(ExprObject { syntax }),2179			EXPR_ARRAY_COMP => Expr::ExprArrayComp(ExprArrayComp { syntax }),2180			EXPR_IMPORT => Expr::ExprImport(ExprImport { syntax }),2181			EXPR_VAR => Expr::ExprVar(ExprVar { syntax }),2182			EXPR_LOCAL => Expr::ExprLocal(ExprLocal { syntax }),2183			EXPR_IF_THEN_ELSE => Expr::ExprIfThenElse(ExprIfThenElse { syntax }),2184			EXPR_FUNCTION => Expr::ExprFunction(ExprFunction { syntax }),2185			EXPR_ASSERT => Expr::ExprAssert(ExprAssert { syntax }),2186			EXPR_ERROR => Expr::ExprError(ExprError { syntax }),2187			_ => return None,2188		};2189		Some(res)2190	}2191	fn syntax(&self) -> &SyntaxNode {2192		match self {2193			Expr::ExprBinary(it) => &it.syntax,2194			Expr::ExprUnary(it) => &it.syntax,2195			Expr::ExprSlice(it) => &it.syntax,2196			Expr::ExprIndex(it) => &it.syntax,2197			Expr::ExprIndexExpr(it) => &it.syntax,2198			Expr::ExprApply(it) => &it.syntax,2199			Expr::ExprObjExtend(it) => &it.syntax,2200			Expr::ExprParened(it) => &it.syntax,2201			Expr::ExprIntrinsicThisFile(it) => &it.syntax,2202			Expr::ExprIntrinsicId(it) => &it.syntax,2203			Expr::ExprIntrinsic(it) => &it.syntax,2204			Expr::ExprString(it) => &it.syntax,2205			Expr::ExprNumber(it) => &it.syntax,2206			Expr::ExprLiteral(it) => &it.syntax,2207			Expr::ExprArray(it) => &it.syntax,2208			Expr::ExprObject(it) => &it.syntax,2209			Expr::ExprArrayComp(it) => &it.syntax,2210			Expr::ExprImport(it) => &it.syntax,2211			Expr::ExprVar(it) => &it.syntax,2212			Expr::ExprLocal(it) => &it.syntax,2213			Expr::ExprIfThenElse(it) => &it.syntax,2214			Expr::ExprFunction(it) => &it.syntax,2215			Expr::ExprAssert(it) => &it.syntax,2216			Expr::ExprError(it) => &it.syntax,2217		}2218	}2219}2220impl From<ObjBodyComp> for ObjBody {2221	fn from(node: ObjBodyComp) -> ObjBody {2222		ObjBody::ObjBodyComp(node)2223	}2224}2225impl From<ObjBodyMemberList> for ObjBody {2226	fn from(node: ObjBodyMemberList) -> ObjBody {2227		ObjBody::ObjBodyMemberList(node)2228	}2229}2230impl AstNode for ObjBody {2231	fn can_cast(kind: SyntaxKind) -> bool {2232		match kind {2233			OBJ_BODY_COMP | OBJ_BODY_MEMBER_LIST => true,2234			_ => false,2235		}2236	}2237	fn cast(syntax: SyntaxNode) -> Option<Self> {2238		let res = match syntax.kind() {2239			OBJ_BODY_COMP => ObjBody::ObjBodyComp(ObjBodyComp { syntax }),2240			OBJ_BODY_MEMBER_LIST => ObjBody::ObjBodyMemberList(ObjBodyMemberList { syntax }),2241			_ => return None,2242		};2243		Some(res)2244	}2245	fn syntax(&self) -> &SyntaxNode {2246		match self {2247			ObjBody::ObjBodyComp(it) => &it.syntax,2248			ObjBody::ObjBodyMemberList(it) => &it.syntax,2249		}2250	}2251}2252impl From<ForSpec> for CompSpec {2253	fn from(node: ForSpec) -> CompSpec {2254		CompSpec::ForSpec(node)2255	}2256}2257impl From<IfSpec> for CompSpec {2258	fn from(node: IfSpec) -> CompSpec {2259		CompSpec::IfSpec(node)2260	}2261}2262impl AstNode for CompSpec {2263	fn can_cast(kind: SyntaxKind) -> bool {2264		match kind {2265			FOR_SPEC | IF_SPEC => true,2266			_ => false,2267		}2268	}2269	fn cast(syntax: SyntaxNode) -> Option<Self> {2270		let res = match syntax.kind() {2271			FOR_SPEC => CompSpec::ForSpec(ForSpec { syntax }),2272			IF_SPEC => CompSpec::IfSpec(IfSpec { syntax }),2273			_ => return None,2274		};2275		Some(res)2276	}2277	fn syntax(&self) -> &SyntaxNode {2278		match self {2279			CompSpec::ForSpec(it) => &it.syntax,2280			CompSpec::IfSpec(it) => &it.syntax,2281		}2282	}2283}2284impl From<BindDestruct> for Bind {2285	fn from(node: BindDestruct) -> Bind {2286		Bind::BindDestruct(node)2287	}2288}2289impl From<BindFunction> for Bind {2290	fn from(node: BindFunction) -> Bind {2291		Bind::BindFunction(node)2292	}2293}2294impl AstNode for Bind {2295	fn can_cast(kind: SyntaxKind) -> bool {2296		match kind {2297			BIND_DESTRUCT | BIND_FUNCTION => true,2298			_ => false,2299		}2300	}2301	fn cast(syntax: SyntaxNode) -> Option<Self> {2302		let res = match syntax.kind() {2303			BIND_DESTRUCT => Bind::BindDestruct(BindDestruct { syntax }),2304			BIND_FUNCTION => Bind::BindFunction(BindFunction { syntax }),2305			_ => return None,2306		};2307		Some(res)2308	}2309	fn syntax(&self) -> &SyntaxNode {2310		match self {2311			Bind::BindDestruct(it) => &it.syntax,2312			Bind::BindFunction(it) => &it.syntax,2313		}2314	}2315}2316impl From<MemberBindStmt> for Member {2317	fn from(node: MemberBindStmt) -> Member {2318		Member::MemberBindStmt(node)2319	}2320}2321impl From<MemberAssertStmt> for Member {2322	fn from(node: MemberAssertStmt) -> Member {2323		Member::MemberAssertStmt(node)2324	}2325}2326impl From<MemberFieldNormal> for Member {2327	fn from(node: MemberFieldNormal) -> Member {2328		Member::MemberFieldNormal(node)2329	}2330}2331impl From<MemberFieldMethod> for Member {2332	fn from(node: MemberFieldMethod) -> Member {2333		Member::MemberFieldMethod(node)2334	}2335}2336impl AstNode for Member {2337	fn can_cast(kind: SyntaxKind) -> bool {2338		match kind {2339			MEMBER_BIND_STMT | MEMBER_ASSERT_STMT | MEMBER_FIELD_NORMAL | MEMBER_FIELD_METHOD => {2340				true2341			}2342			_ => false,2343		}2344	}2345	fn cast(syntax: SyntaxNode) -> Option<Self> {2346		let res = match syntax.kind() {2347			MEMBER_BIND_STMT => Member::MemberBindStmt(MemberBindStmt { syntax }),2348			MEMBER_ASSERT_STMT => Member::MemberAssertStmt(MemberAssertStmt { syntax }),2349			MEMBER_FIELD_NORMAL => Member::MemberFieldNormal(MemberFieldNormal { syntax }),2350			MEMBER_FIELD_METHOD => Member::MemberFieldMethod(MemberFieldMethod { syntax }),2351			_ => return None,2352		};2353		Some(res)2354	}2355	fn syntax(&self) -> &SyntaxNode {2356		match self {2357			Member::MemberBindStmt(it) => &it.syntax,2358			Member::MemberAssertStmt(it) => &it.syntax,2359			Member::MemberFieldNormal(it) => &it.syntax,2360			Member::MemberFieldMethod(it) => &it.syntax,2361		}2362	}2363}2364impl From<FieldNameFixed> for FieldName {2365	fn from(node: FieldNameFixed) -> FieldName {2366		FieldName::FieldNameFixed(node)2367	}2368}2369impl From<FieldNameDynamic> for FieldName {2370	fn from(node: FieldNameDynamic) -> FieldName {2371		FieldName::FieldNameDynamic(node)2372	}2373}2374impl AstNode for FieldName {2375	fn can_cast(kind: SyntaxKind) -> bool {2376		match kind {2377			FIELD_NAME_FIXED | FIELD_NAME_DYNAMIC => true,2378			_ => false,2379		}2380	}2381	fn cast(syntax: SyntaxNode) -> Option<Self> {2382		let res = match syntax.kind() {2383			FIELD_NAME_FIXED => FieldName::FieldNameFixed(FieldNameFixed { syntax }),2384			FIELD_NAME_DYNAMIC => FieldName::FieldNameDynamic(FieldNameDynamic { syntax }),2385			_ => return None,2386		};2387		Some(res)2388	}2389	fn syntax(&self) -> &SyntaxNode {2390		match self {2391			FieldName::FieldNameFixed(it) => &it.syntax,2392			FieldName::FieldNameDynamic(it) => &it.syntax,2393		}2394	}2395}2396impl From<DestructFull> for Destruct {2397	fn from(node: DestructFull) -> Destruct {2398		Destruct::DestructFull(node)2399	}2400}2401impl From<DestructSkip> for Destruct {2402	fn from(node: DestructSkip) -> Destruct {2403		Destruct::DestructSkip(node)2404	}2405}2406impl From<DestructArray> for Destruct {2407	fn from(node: DestructArray) -> Destruct {2408		Destruct::DestructArray(node)2409	}2410}2411impl From<DestructObject> for Destruct {2412	fn from(node: DestructObject) -> Destruct {2413		Destruct::DestructObject(node)2414	}2415}2416impl AstNode for Destruct {2417	fn can_cast(kind: SyntaxKind) -> bool {2418		match kind {2419			DESTRUCT_FULL | DESTRUCT_SKIP | DESTRUCT_ARRAY | DESTRUCT_OBJECT => true,2420			_ => false,2421		}2422	}2423	fn cast(syntax: SyntaxNode) -> Option<Self> {2424		let res = match syntax.kind() {2425			DESTRUCT_FULL => Destruct::DestructFull(DestructFull { syntax }),2426			DESTRUCT_SKIP => Destruct::DestructSkip(DestructSkip { syntax }),2427			DESTRUCT_ARRAY => Destruct::DestructArray(DestructArray { syntax }),2428			DESTRUCT_OBJECT => Destruct::DestructObject(DestructObject { syntax }),2429			_ => return None,2430		};2431		Some(res)2432	}2433	fn syntax(&self) -> &SyntaxNode {2434		match self {2435			Destruct::DestructFull(it) => &it.syntax,2436			Destruct::DestructSkip(it) => &it.syntax,2437			Destruct::DestructArray(it) => &it.syntax,2438			Destruct::DestructObject(it) => &it.syntax,2439		}2440	}2441}2442impl From<DestructArrayElement> for DestructArrayPart {2443	fn from(node: DestructArrayElement) -> DestructArrayPart {2444		DestructArrayPart::DestructArrayElement(node)2445	}2446}2447impl From<DestructRest> for DestructArrayPart {2448	fn from(node: DestructRest) -> DestructArrayPart {2449		DestructArrayPart::DestructRest(node)2450	}2451}2452impl AstNode for DestructArrayPart {2453	fn can_cast(kind: SyntaxKind) -> bool {2454		match kind {2455			DESTRUCT_ARRAY_ELEMENT | DESTRUCT_REST => true,2456			_ => false,2457		}2458	}2459	fn cast(syntax: SyntaxNode) -> Option<Self> {2460		let res = match syntax.kind() {2461			DESTRUCT_ARRAY_ELEMENT => {2462				DestructArrayPart::DestructArrayElement(DestructArrayElement { syntax })2463			}2464			DESTRUCT_REST => DestructArrayPart::DestructRest(DestructRest { syntax }),2465			_ => return None,2466		};2467		Some(res)2468	}2469	fn syntax(&self) -> &SyntaxNode {2470		match self {2471			DestructArrayPart::DestructArrayElement(it) => &it.syntax,2472			DestructArrayPart::DestructRest(it) => &it.syntax,2473		}2474	}2475}2476impl AstToken for BinaryOperator {2477	fn can_cast(kind: SyntaxKind) -> bool {2478		BinaryOperatorKind::can_cast(kind)2479	}2480	fn cast(syntax: SyntaxToken) -> Option<Self> {2481		let kind = BinaryOperatorKind::cast(syntax.kind())?;2482		Some(BinaryOperator { syntax, kind })2483	}2484	fn syntax(&self) -> &SyntaxToken {2485		&self.syntax2486	}2487}2488impl BinaryOperatorKind {2489	fn can_cast(kind: SyntaxKind) -> bool {2490		match kind {2491			OR | AND | BIT_OR | BIT_XOR | BIT_AND | EQ | NE | LT | GT | LE | GE | IN_KW | LHS2492			| RHS | PLUS | MINUS | MUL | DIV | MODULO | META_OBJECT_APPLY | ERROR_NO_OPERATOR => true,2493			_ => false,2494		}2495	}2496	pub fn cast(kind: SyntaxKind) -> Option<Self> {2497		let res = match kind {2498			OR => Self::Or,2499			AND => Self::And,2500			BIT_OR => Self::BitOr,2501			BIT_XOR => Self::BitXor,2502			BIT_AND => Self::BitAnd,2503			EQ => Self::Eq,2504			NE => Self::Ne,2505			LT => Self::Lt,2506			GT => Self::Gt,2507			LE => Self::Le,2508			GE => Self::Ge,2509			IN_KW => Self::InKw,2510			LHS => Self::Lhs,2511			RHS => Self::Rhs,2512			PLUS => Self::Plus,2513			MINUS => Self::Minus,2514			MUL => Self::Mul,2515			DIV => Self::Div,2516			MODULO => Self::Modulo,2517			META_OBJECT_APPLY => Self::MetaObjectApply,2518			ERROR_NO_OPERATOR => Self::ErrorNoOperator,2519			_ => return None,2520		};2521		Some(res)2522	}2523}2524impl BinaryOperator {2525	pub fn kind(&self) -> BinaryOperatorKind {2526		self.kind2527	}2528}2529impl std::fmt::Display for BinaryOperator {2530	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2531		std::fmt::Display::fmt(self.syntax(), f)2532	}2533}2534impl AstToken for UnaryOperator {2535	fn can_cast(kind: SyntaxKind) -> bool {2536		UnaryOperatorKind::can_cast(kind)2537	}2538	fn cast(syntax: SyntaxToken) -> Option<Self> {2539		let kind = UnaryOperatorKind::cast(syntax.kind())?;2540		Some(UnaryOperator { syntax, kind })2541	}2542	fn syntax(&self) -> &SyntaxToken {2543		&self.syntax2544	}2545}2546impl UnaryOperatorKind {2547	fn can_cast(kind: SyntaxKind) -> bool {2548		match kind {2549			MINUS | NOT | BIT_NOT => true,2550			_ => false,2551		}2552	}2553	pub fn cast(kind: SyntaxKind) -> Option<Self> {2554		let res = match kind {2555			MINUS => Self::Minus,2556			NOT => Self::Not,2557			BIT_NOT => Self::BitNot,2558			_ => return None,2559		};2560		Some(res)2561	}2562}2563impl UnaryOperator {2564	pub fn kind(&self) -> UnaryOperatorKind {2565		self.kind2566	}2567}2568impl std::fmt::Display for UnaryOperator {2569	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2570		std::fmt::Display::fmt(self.syntax(), f)2571	}2572}2573impl AstToken for Literal {2574	fn can_cast(kind: SyntaxKind) -> bool {2575		LiteralKind::can_cast(kind)2576	}2577	fn cast(syntax: SyntaxToken) -> Option<Self> {2578		let kind = LiteralKind::cast(syntax.kind())?;2579		Some(Literal { syntax, kind })2580	}2581	fn syntax(&self) -> &SyntaxToken {2582		&self.syntax2583	}2584}2585impl LiteralKind {2586	fn can_cast(kind: SyntaxKind) -> bool {2587		match kind {2588			NULL_KW | TRUE_KW | FALSE_KW | SELF_KW | DOLLAR | SUPER_KW => true,2589			_ => false,2590		}2591	}2592	pub fn cast(kind: SyntaxKind) -> Option<Self> {2593		let res = match kind {2594			NULL_KW => Self::NullKw,2595			TRUE_KW => Self::TrueKw,2596			FALSE_KW => Self::FalseKw,2597			SELF_KW => Self::SelfKw,2598			DOLLAR => Self::Dollar,2599			SUPER_KW => Self::SuperKw,2600			_ => return None,2601		};2602		Some(res)2603	}2604}2605impl Literal {2606	pub fn kind(&self) -> LiteralKind {2607		self.kind2608	}2609}2610impl std::fmt::Display for Literal {2611	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2612		std::fmt::Display::fmt(self.syntax(), f)2613	}2614}2615impl AstToken for Text {2616	fn can_cast(kind: SyntaxKind) -> bool {2617		TextKind::can_cast(kind)2618	}2619	fn cast(syntax: SyntaxToken) -> Option<Self> {2620		let kind = TextKind::cast(syntax.kind())?;2621		Some(Text { syntax, kind })2622	}2623	fn syntax(&self) -> &SyntaxToken {2624		&self.syntax2625	}2626}2627impl TextKind {2628	fn can_cast(kind: SyntaxKind) -> bool {2629		match kind {2630			STRING_DOUBLE2631			| ERROR_STRING_DOUBLE_UNTERMINATED2632			| STRING_SINGLE2633			| ERROR_STRING_SINGLE_UNTERMINATED2634			| STRING_DOUBLE_VERBATIM2635			| ERROR_STRING_DOUBLE_VERBATIM_UNTERMINATED2636			| STRING_SINGLE_VERBATIM2637			| ERROR_STRING_SINGLE_VERBATIM_UNTERMINATED2638			| ERROR_STRING_VERBATIM_MISSING_QUOTES2639			| STRING_BLOCK2640			| ERROR_STRING_BLOCK_UNEXPECTED_END2641			| ERROR_STRING_BLOCK_MISSING_NEW_LINE2642			| ERROR_STRING_BLOCK_MISSING_TERMINATION2643			| ERROR_STRING_BLOCK_MISSING_INDENT => true,2644			_ => false,2645		}2646	}2647	pub fn cast(kind: SyntaxKind) -> Option<Self> {2648		let res = match kind {2649			STRING_DOUBLE => Self::StringDouble,2650			ERROR_STRING_DOUBLE_UNTERMINATED => Self::ErrorStringDoubleUnterminated,2651			STRING_SINGLE => Self::StringSingle,2652			ERROR_STRING_SINGLE_UNTERMINATED => Self::ErrorStringSingleUnterminated,2653			STRING_DOUBLE_VERBATIM => Self::StringDoubleVerbatim,2654			ERROR_STRING_DOUBLE_VERBATIM_UNTERMINATED => {2655				Self::ErrorStringDoubleVerbatimUnterminated2656			}2657			STRING_SINGLE_VERBATIM => Self::StringSingleVerbatim,2658			ERROR_STRING_SINGLE_VERBATIM_UNTERMINATED => {2659				Self::ErrorStringSingleVerbatimUnterminated2660			}2661			ERROR_STRING_VERBATIM_MISSING_QUOTES => Self::ErrorStringVerbatimMissingQuotes,2662			STRING_BLOCK => Self::StringBlock,2663			ERROR_STRING_BLOCK_UNEXPECTED_END => Self::ErrorStringBlockUnexpectedEnd,2664			ERROR_STRING_BLOCK_MISSING_NEW_LINE => Self::ErrorStringBlockMissingNewLine,2665			ERROR_STRING_BLOCK_MISSING_TERMINATION => Self::ErrorStringBlockMissingTermination,2666			ERROR_STRING_BLOCK_MISSING_INDENT => Self::ErrorStringBlockMissingIndent,2667			_ => return None,2668		};2669		Some(res)2670	}2671}2672impl Text {2673	pub fn kind(&self) -> TextKind {2674		self.kind2675	}2676}2677impl std::fmt::Display for Text {2678	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2679		std::fmt::Display::fmt(self.syntax(), f)2680	}2681}2682impl AstToken for Number {2683	fn can_cast(kind: SyntaxKind) -> bool {2684		NumberKind::can_cast(kind)2685	}2686	fn cast(syntax: SyntaxToken) -> Option<Self> {2687		let kind = NumberKind::cast(syntax.kind())?;2688		Some(Number { syntax, kind })2689	}2690	fn syntax(&self) -> &SyntaxToken {2691		&self.syntax2692	}2693}2694impl NumberKind {2695	fn can_cast(kind: SyntaxKind) -> bool {2696		match kind {2697			FLOAT2698			| ERROR_FLOAT_JUNK_AFTER_POINT2699			| ERROR_FLOAT_JUNK_AFTER_EXPONENT2700			| ERROR_FLOAT_JUNK_AFTER_EXPONENT_SIGN => true,2701			_ => false,2702		}2703	}2704	pub fn cast(kind: SyntaxKind) -> Option<Self> {2705		let res = match kind {2706			FLOAT => Self::Float,2707			ERROR_FLOAT_JUNK_AFTER_POINT => Self::ErrorFloatJunkAfterPoint,2708			ERROR_FLOAT_JUNK_AFTER_EXPONENT => Self::ErrorFloatJunkAfterExponent,2709			ERROR_FLOAT_JUNK_AFTER_EXPONENT_SIGN => Self::ErrorFloatJunkAfterExponentSign,2710			_ => return None,2711		};2712		Some(res)2713	}2714}2715impl Number {2716	pub fn kind(&self) -> NumberKind {2717		self.kind2718	}2719}2720impl std::fmt::Display for Number {2721	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2722		std::fmt::Display::fmt(self.syntax(), f)2723	}2724}2725impl AstToken for ImportKind {2726	fn can_cast(kind: SyntaxKind) -> bool {2727		ImportKindKind::can_cast(kind)2728	}2729	fn cast(syntax: SyntaxToken) -> Option<Self> {2730		let kind = ImportKindKind::cast(syntax.kind())?;2731		Some(ImportKind { syntax, kind })2732	}2733	fn syntax(&self) -> &SyntaxToken {2734		&self.syntax2735	}2736}2737impl ImportKindKind {2738	fn can_cast(kind: SyntaxKind) -> bool {2739		match kind {2740			IMPORTSTR_KW | IMPORTBIN_KW | IMPORT_KW => true,2741			_ => false,2742		}2743	}2744	pub fn cast(kind: SyntaxKind) -> Option<Self> {2745		let res = match kind {2746			IMPORTSTR_KW => Self::ImportstrKw,2747			IMPORTBIN_KW => Self::ImportbinKw,2748			IMPORT_KW => Self::ImportKw,2749			_ => return None,2750		};2751		Some(res)2752	}2753}2754impl ImportKind {2755	pub fn kind(&self) -> ImportKindKind {2756		self.kind2757	}2758}2759impl std::fmt::Display for ImportKind {2760	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2761		std::fmt::Display::fmt(self.syntax(), f)2762	}2763}2764impl AstToken for Visibility {2765	fn can_cast(kind: SyntaxKind) -> bool {2766		VisibilityKind::can_cast(kind)2767	}2768	fn cast(syntax: SyntaxToken) -> Option<Self> {2769		let kind = VisibilityKind::cast(syntax.kind())?;2770		Some(Visibility { syntax, kind })2771	}2772	fn syntax(&self) -> &SyntaxToken {2773		&self.syntax2774	}2775}2776impl VisibilityKind {2777	fn can_cast(kind: SyntaxKind) -> bool {2778		match kind {2779			COLONCOLONCOLON | COLONCOLON | COLON => true,2780			_ => false,2781		}2782	}2783	pub fn cast(kind: SyntaxKind) -> Option<Self> {2784		let res = match kind {2785			COLONCOLONCOLON => Self::Coloncoloncolon,2786			COLONCOLON => Self::Coloncolon,2787			COLON => Self::Colon,2788			_ => return None,2789		};2790		Some(res)2791	}2792}2793impl Visibility {2794	pub fn kind(&self) -> VisibilityKind {2795		self.kind2796	}2797}2798impl std::fmt::Display for Visibility {2799	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2800		std::fmt::Display::fmt(self.syntax(), f)2801	}2802}2803impl AstToken for Trivia {2804	fn can_cast(kind: SyntaxKind) -> bool {2805		TriviaKind::can_cast(kind)2806	}2807	fn cast(syntax: SyntaxToken) -> Option<Self> {2808		let kind = TriviaKind::cast(syntax.kind())?;2809		Some(Trivia { syntax, kind })2810	}2811	fn syntax(&self) -> &SyntaxToken {2812		&self.syntax2813	}2814}2815impl TriviaKind {2816	fn can_cast(kind: SyntaxKind) -> bool {2817		match kind {2818			WHITESPACE2819			| MULTI_LINE_COMMENT2820			| ERROR_COMMENT_TOO_SHORT2821			| ERROR_COMMENT_UNTERMINATED2822			| SINGLE_LINE_HASH_COMMENT2823			| SINGLE_LINE_SLASH_COMMENT => true,2824			_ => false,2825		}2826	}2827	pub fn cast(kind: SyntaxKind) -> Option<Self> {2828		let res = match kind {2829			WHITESPACE => Self::Whitespace,2830			MULTI_LINE_COMMENT => Self::MultiLineComment,2831			ERROR_COMMENT_TOO_SHORT => Self::ErrorCommentTooShort,2832			ERROR_COMMENT_UNTERMINATED => Self::ErrorCommentUnterminated,2833			SINGLE_LINE_HASH_COMMENT => Self::SingleLineHashComment,2834			SINGLE_LINE_SLASH_COMMENT => Self::SingleLineSlashComment,2835			_ => return None,2836		};2837		Some(res)2838	}2839}2840impl Trivia {2841	pub fn kind(&self) -> TriviaKind {2842		self.kind2843	}2844}2845impl std::fmt::Display for Trivia {2846	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2847		std::fmt::Display::fmt(self.syntax(), f)2848	}2849}2850impl AstToken for ParsingError {2851	fn can_cast(kind: SyntaxKind) -> bool {2852		ParsingErrorKind::can_cast(kind)2853	}2854	fn cast(syntax: SyntaxToken) -> Option<Self> {2855		let kind = ParsingErrorKind::cast(syntax.kind())?;2856		Some(ParsingError { syntax, kind })2857	}2858	fn syntax(&self) -> &SyntaxToken {2859		&self.syntax2860	}2861}2862impl ParsingErrorKind {2863	fn can_cast(kind: SyntaxKind) -> bool {2864		match kind {2865			ERROR_MISSING_TOKEN | ERROR_UNEXPECTED_TOKEN | ERROR_CUSTOM => true,2866			_ => false,2867		}2868	}2869	pub fn cast(kind: SyntaxKind) -> Option<Self> {2870		let res = match kind {2871			ERROR_MISSING_TOKEN => Self::ErrorMissingToken,2872			ERROR_UNEXPECTED_TOKEN => Self::ErrorUnexpectedToken,2873			ERROR_CUSTOM => Self::ErrorCustom,2874			_ => return None,2875		};2876		Some(res)2877	}2878}2879impl ParsingError {2880	pub fn kind(&self) -> ParsingErrorKind {2881		self.kind2882	}2883}2884impl std::fmt::Display for ParsingError {2885	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2886		std::fmt::Display::fmt(self.syntax(), f)2887	}2888}2889impl std::fmt::Display for Expr {2890	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2891		std::fmt::Display::fmt(self.syntax(), f)2892	}2893}2894impl std::fmt::Display for ObjBody {2895	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2896		std::fmt::Display::fmt(self.syntax(), f)2897	}2898}2899impl std::fmt::Display for CompSpec {2900	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2901		std::fmt::Display::fmt(self.syntax(), f)2902	}2903}2904impl std::fmt::Display for Bind {2905	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2906		std::fmt::Display::fmt(self.syntax(), f)2907	}2908}2909impl std::fmt::Display for Member {2910	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2911		std::fmt::Display::fmt(self.syntax(), f)2912	}2913}2914impl std::fmt::Display for FieldName {2915	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2916		std::fmt::Display::fmt(self.syntax(), f)2917	}2918}2919impl std::fmt::Display for Destruct {2920	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2921		std::fmt::Display::fmt(self.syntax(), f)2922	}2923}2924impl std::fmt::Display for DestructArrayPart {2925	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2926		std::fmt::Display::fmt(self.syntax(), f)2927	}2928}2929impl std::fmt::Display for SourceFile {2930	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2931		std::fmt::Display::fmt(self.syntax(), f)2932	}2933}2934impl std::fmt::Display for ExprBinary {2935	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2936		std::fmt::Display::fmt(self.syntax(), f)2937	}2938}2939impl std::fmt::Display for LhsExpr {2940	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2941		std::fmt::Display::fmt(self.syntax(), f)2942	}2943}2944impl std::fmt::Display for ExprUnary {2945	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2946		std::fmt::Display::fmt(self.syntax(), f)2947	}2948}2949impl std::fmt::Display for ExprSlice {2950	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2951		std::fmt::Display::fmt(self.syntax(), f)2952	}2953}2954impl std::fmt::Display for SliceDesc {2955	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2956		std::fmt::Display::fmt(self.syntax(), f)2957	}2958}2959impl std::fmt::Display for ExprIndex {2960	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2961		std::fmt::Display::fmt(self.syntax(), f)2962	}2963}2964impl std::fmt::Display for Name {2965	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2966		std::fmt::Display::fmt(self.syntax(), f)2967	}2968}2969impl std::fmt::Display for ExprIndexExpr {2970	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2971		std::fmt::Display::fmt(self.syntax(), f)2972	}2973}2974impl std::fmt::Display for ExprApply {2975	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2976		std::fmt::Display::fmt(self.syntax(), f)2977	}2978}2979impl std::fmt::Display for ArgsDesc {2980	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2981		std::fmt::Display::fmt(self.syntax(), f)2982	}2983}2984impl std::fmt::Display for ExprObjExtend {2985	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2986		std::fmt::Display::fmt(self.syntax(), f)2987	}2988}2989impl std::fmt::Display for ExprParened {2990	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2991		std::fmt::Display::fmt(self.syntax(), f)2992	}2993}2994impl std::fmt::Display for ExprLiteral {2995	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2996		std::fmt::Display::fmt(self.syntax(), f)2997	}2998}2999impl std::fmt::Display for ExprIntrinsicThisFile {3000	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3001		std::fmt::Display::fmt(self.syntax(), f)3002	}3003}3004impl std::fmt::Display for ExprIntrinsicId {3005	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3006		std::fmt::Display::fmt(self.syntax(), f)3007	}3008}3009impl std::fmt::Display for ExprIntrinsic {3010	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3011		std::fmt::Display::fmt(self.syntax(), f)3012	}3013}3014impl std::fmt::Display for ExprString {3015	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3016		std::fmt::Display::fmt(self.syntax(), f)3017	}3018}3019impl std::fmt::Display for ExprNumber {3020	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3021		std::fmt::Display::fmt(self.syntax(), f)3022	}3023}3024impl std::fmt::Display for ExprArray {3025	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3026		std::fmt::Display::fmt(self.syntax(), f)3027	}3028}3029impl std::fmt::Display for ExprObject {3030	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3031		std::fmt::Display::fmt(self.syntax(), f)3032	}3033}3034impl std::fmt::Display for ExprArrayComp {3035	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3036		std::fmt::Display::fmt(self.syntax(), f)3037	}3038}3039impl std::fmt::Display for ExprImport {3040	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3041		std::fmt::Display::fmt(self.syntax(), f)3042	}3043}3044impl std::fmt::Display for ExprVar {3045	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3046		std::fmt::Display::fmt(self.syntax(), f)3047	}3048}3049impl std::fmt::Display for ExprLocal {3050	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3051		std::fmt::Display::fmt(self.syntax(), f)3052	}3053}3054impl std::fmt::Display for ExprIfThenElse {3055	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3056		std::fmt::Display::fmt(self.syntax(), f)3057	}3058}3059impl std::fmt::Display for TrueExpr {3060	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3061		std::fmt::Display::fmt(self.syntax(), f)3062	}3063}3064impl std::fmt::Display for FalseExpr {3065	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3066		std::fmt::Display::fmt(self.syntax(), f)3067	}3068}3069impl std::fmt::Display for ExprFunction {3070	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3071		std::fmt::Display::fmt(self.syntax(), f)3072	}3073}3074impl std::fmt::Display for ParamsDesc {3075	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3076		std::fmt::Display::fmt(self.syntax(), f)3077	}3078}3079impl std::fmt::Display for ExprAssert {3080	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3081		std::fmt::Display::fmt(self.syntax(), f)3082	}3083}3084impl std::fmt::Display for Assertion {3085	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3086		std::fmt::Display::fmt(self.syntax(), f)3087	}3088}3089impl std::fmt::Display for ExprError {3090	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3091		std::fmt::Display::fmt(self.syntax(), f)3092	}3093}3094impl std::fmt::Display for SliceDescEnd {3095	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3096		std::fmt::Display::fmt(self.syntax(), f)3097	}3098}3099impl std::fmt::Display for SliceDescStep {3100	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3101		std::fmt::Display::fmt(self.syntax(), f)3102	}3103}3104impl std::fmt::Display for Arg {3105	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3106		std::fmt::Display::fmt(self.syntax(), f)3107	}3108}3109impl std::fmt::Display for ObjBodyComp {3110	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3111		std::fmt::Display::fmt(self.syntax(), f)3112	}3113}3114impl std::fmt::Display for ObjLocalPostComma {3115	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3116		std::fmt::Display::fmt(self.syntax(), f)3117	}3118}3119impl std::fmt::Display for ObjLocalPreComma {3120	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3121		std::fmt::Display::fmt(self.syntax(), f)3122	}3123}3124impl std::fmt::Display for ObjBodyMemberList {3125	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3126		std::fmt::Display::fmt(self.syntax(), f)3127	}3128}3129impl std::fmt::Display for ObjLocal {3130	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3131		std::fmt::Display::fmt(self.syntax(), f)3132	}3133}3134impl std::fmt::Display for MemberBindStmt {3135	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3136		std::fmt::Display::fmt(self.syntax(), f)3137	}3138}3139impl std::fmt::Display for MemberAssertStmt {3140	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3141		std::fmt::Display::fmt(self.syntax(), f)3142	}3143}3144impl std::fmt::Display for MemberFieldNormal {3145	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3146		std::fmt::Display::fmt(self.syntax(), f)3147	}3148}3149impl std::fmt::Display for MemberFieldMethod {3150	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3151		std::fmt::Display::fmt(self.syntax(), f)3152	}3153}3154impl std::fmt::Display for FieldNameFixed {3155	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3156		std::fmt::Display::fmt(self.syntax(), f)3157	}3158}3159impl std::fmt::Display for FieldNameDynamic {3160	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3161		std::fmt::Display::fmt(self.syntax(), f)3162	}3163}3164impl std::fmt::Display for ForSpec {3165	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3166		std::fmt::Display::fmt(self.syntax(), f)3167	}3168}3169impl std::fmt::Display for IfSpec {3170	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3171		std::fmt::Display::fmt(self.syntax(), f)3172	}3173}3174impl std::fmt::Display for BindDestruct {3175	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3176		std::fmt::Display::fmt(self.syntax(), f)3177	}3178}3179impl std::fmt::Display for BindFunction {3180	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3181		std::fmt::Display::fmt(self.syntax(), f)3182	}3183}3184impl std::fmt::Display for Param {3185	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3186		std::fmt::Display::fmt(self.syntax(), f)3187	}3188}3189impl std::fmt::Display for DestructFull {3190	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3191		std::fmt::Display::fmt(self.syntax(), f)3192	}3193}3194impl std::fmt::Display for DestructSkip {3195	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3196		std::fmt::Display::fmt(self.syntax(), f)3197	}3198}3199impl std::fmt::Display for DestructArray {3200	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3201		std::fmt::Display::fmt(self.syntax(), f)3202	}3203}3204impl std::fmt::Display for DestructObject {3205	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3206		std::fmt::Display::fmt(self.syntax(), f)3207	}3208}3209impl std::fmt::Display for DestructObjectField {3210	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3211		std::fmt::Display::fmt(self.syntax(), f)3212	}3213}3214impl std::fmt::Display for DestructRest {3215	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3216		std::fmt::Display::fmt(self.syntax(), f)3217	}3218}3219impl std::fmt::Display for DestructArrayElement {3220	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3221		std::fmt::Display::fmt(self.syntax(), f)3222	}3223}