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

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 MemberField {647	pub(crate) syntax: SyntaxNode,648}649impl MemberField {650	pub fn field(&self) -> Option<Field> {651		support::child(&self.syntax)652	}653}654655#[derive(Debug, Clone, PartialEq, Eq, Hash)]656pub struct FieldNormal {657	pub(crate) syntax: SyntaxNode,658}659impl FieldNormal {660	pub fn field_name(&self) -> Option<FieldName> {661		support::child(&self.syntax)662	}663	pub fn plus_token(&self) -> Option<SyntaxToken> {664		support::token(&self.syntax, T![+])665	}666	pub fn visibility(&self) -> Option<Visibility> {667		support::token_child(&self.syntax)668	}669	pub fn expr(&self) -> Option<Expr> {670		support::child(&self.syntax)671	}672}673674#[derive(Debug, Clone, PartialEq, Eq, Hash)]675pub struct FieldMethod {676	pub(crate) syntax: SyntaxNode,677}678impl FieldMethod {679	pub fn field_name(&self) -> Option<FieldName> {680		support::child(&self.syntax)681	}682	pub fn params_desc(&self) -> Option<ParamsDesc> {683		support::child(&self.syntax)684	}685	pub fn visibility(&self) -> Option<Visibility> {686		support::token_child(&self.syntax)687	}688	pub fn expr(&self) -> Option<Expr> {689		support::child(&self.syntax)690	}691}692693#[derive(Debug, Clone, PartialEq, Eq, Hash)]694pub struct FieldNameFixed {695	pub(crate) syntax: SyntaxNode,696}697impl FieldNameFixed {698	pub fn id(&self) -> Option<Name> {699		support::child(&self.syntax)700	}701	pub fn text(&self) -> Option<Text> {702		support::token_child(&self.syntax)703	}704}705706#[derive(Debug, Clone, PartialEq, Eq, Hash)]707pub struct FieldNameDynamic {708	pub(crate) syntax: SyntaxNode,709}710impl FieldNameDynamic {711	pub fn l_brack_token(&self) -> Option<SyntaxToken> {712		support::token(&self.syntax, T!['['])713	}714	pub fn expr(&self) -> Option<Expr> {715		support::child(&self.syntax)716	}717	pub fn r_brack_token(&self) -> Option<SyntaxToken> {718		support::token(&self.syntax, T![']'])719	}720}721722#[derive(Debug, Clone, PartialEq, Eq, Hash)]723pub struct ForSpec {724	pub(crate) syntax: SyntaxNode,725}726impl ForSpec {727	pub fn for_kw_token(&self) -> Option<SyntaxToken> {728		support::token(&self.syntax, T![for])729	}730	pub fn bind(&self) -> Option<Name> {731		support::child(&self.syntax)732	}733	pub fn in_kw_token(&self) -> Option<SyntaxToken> {734		support::token(&self.syntax, T![in])735	}736	pub fn expr(&self) -> Option<Expr> {737		support::child(&self.syntax)738	}739}740741#[derive(Debug, Clone, PartialEq, Eq, Hash)]742pub struct IfSpec {743	pub(crate) syntax: SyntaxNode,744}745impl IfSpec {746	pub fn if_kw_token(&self) -> Option<SyntaxToken> {747		support::token(&self.syntax, T![if])748	}749	pub fn expr(&self) -> Option<Expr> {750		support::child(&self.syntax)751	}752}753754#[derive(Debug, Clone, PartialEq, Eq, Hash)]755pub struct BindDestruct {756	pub(crate) syntax: SyntaxNode,757}758impl BindDestruct {759	pub fn into(&self) -> Option<Destruct> {760		support::child(&self.syntax)761	}762	pub fn assign_token(&self) -> Option<SyntaxToken> {763		support::token(&self.syntax, T![=])764	}765	pub fn value(&self) -> Option<Expr> {766		support::child(&self.syntax)767	}768}769770#[derive(Debug, Clone, PartialEq, Eq, Hash)]771pub struct BindFunction {772	pub(crate) syntax: SyntaxNode,773}774impl BindFunction {775	pub fn name(&self) -> Option<Name> {776		support::child(&self.syntax)777	}778	pub fn params(&self) -> Option<ParamsDesc> {779		support::child(&self.syntax)780	}781	pub fn assign_token(&self) -> Option<SyntaxToken> {782		support::token(&self.syntax, T![=])783	}784	pub fn value(&self) -> Option<Expr> {785		support::child(&self.syntax)786	}787}788789#[derive(Debug, Clone, PartialEq, Eq, Hash)]790pub struct Param {791	pub(crate) syntax: SyntaxNode,792}793impl Param {794	pub fn destruct(&self) -> Option<Destruct> {795		support::child(&self.syntax)796	}797	pub fn assign_token(&self) -> Option<SyntaxToken> {798		support::token(&self.syntax, T![=])799	}800	pub fn expr(&self) -> Option<Expr> {801		support::child(&self.syntax)802	}803}804805#[derive(Debug, Clone, PartialEq, Eq, Hash)]806pub struct DestructFull {807	pub(crate) syntax: SyntaxNode,808}809impl DestructFull {810	pub fn name(&self) -> Option<Name> {811		support::child(&self.syntax)812	}813}814815#[derive(Debug, Clone, PartialEq, Eq, Hash)]816pub struct DestructSkip {817	pub(crate) syntax: SyntaxNode,818}819impl DestructSkip {820	pub fn question_mark_token(&self) -> Option<SyntaxToken> {821		support::token(&self.syntax, T![?])822	}823}824825#[derive(Debug, Clone, PartialEq, Eq, Hash)]826pub struct DestructArray {827	pub(crate) syntax: SyntaxNode,828}829impl DestructArray {830	pub fn l_brack_token(&self) -> Option<SyntaxToken> {831		support::token(&self.syntax, T!['['])832	}833	pub fn destruct_array_parts(&self) -> AstChildren<DestructArrayPart> {834		support::children(&self.syntax)835	}836	pub fn r_brack_token(&self) -> Option<SyntaxToken> {837		support::token(&self.syntax, T![']'])838	}839}840841#[derive(Debug, Clone, PartialEq, Eq, Hash)]842pub struct DestructObject {843	pub(crate) syntax: SyntaxNode,844}845impl DestructObject {846	pub fn l_brace_token(&self) -> Option<SyntaxToken> {847		support::token(&self.syntax, T!['{'])848	}849	pub fn destruct_object_fields(&self) -> AstChildren<DestructObjectField> {850		support::children(&self.syntax)851	}852	pub fn destruct_rest(&self) -> Option<DestructRest> {853		support::child(&self.syntax)854	}855	pub fn comma_token(&self) -> Option<SyntaxToken> {856		support::token(&self.syntax, T![,])857	}858	pub fn r_brace_token(&self) -> Option<SyntaxToken> {859		support::token(&self.syntax, T!['}'])860	}861}862863#[derive(Debug, Clone, PartialEq, Eq, Hash)]864pub struct DestructObjectField {865	pub(crate) syntax: SyntaxNode,866}867impl DestructObjectField {868	pub fn field(&self) -> Option<Name> {869		support::child(&self.syntax)870	}871	pub fn colon_token(&self) -> Option<SyntaxToken> {872		support::token(&self.syntax, T![:])873	}874	pub fn destruct(&self) -> Option<Destruct> {875		support::child(&self.syntax)876	}877	pub fn assign_token(&self) -> Option<SyntaxToken> {878		support::token(&self.syntax, T![=])879	}880	pub fn expr(&self) -> Option<Expr> {881		support::child(&self.syntax)882	}883}884885#[derive(Debug, Clone, PartialEq, Eq, Hash)]886pub struct DestructRest {887	pub(crate) syntax: SyntaxNode,888}889impl DestructRest {890	pub fn dotdotdot_token(&self) -> Option<SyntaxToken> {891		support::token(&self.syntax, T![...])892	}893	pub fn into(&self) -> Option<Name> {894		support::child(&self.syntax)895	}896}897898#[derive(Debug, Clone, PartialEq, Eq, Hash)]899pub struct DestructArrayElement {900	pub(crate) syntax: SyntaxNode,901}902impl DestructArrayElement {903	pub fn destruct(&self) -> Option<Destruct> {904		support::child(&self.syntax)905	}906}907908#[derive(Debug, Clone, PartialEq, Eq, Hash)]909pub enum Expr {910	ExprBinary(ExprBinary),911	ExprUnary(ExprUnary),912	ExprSlice(ExprSlice),913	ExprIndex(ExprIndex),914	ExprIndexExpr(ExprIndexExpr),915	ExprApply(ExprApply),916	ExprObjExtend(ExprObjExtend),917	ExprParened(ExprParened),918	ExprIntrinsicThisFile(ExprIntrinsicThisFile),919	ExprIntrinsicId(ExprIntrinsicId),920	ExprIntrinsic(ExprIntrinsic),921	ExprString(ExprString),922	ExprNumber(ExprNumber),923	ExprLiteral(ExprLiteral),924	ExprArray(ExprArray),925	ExprObject(ExprObject),926	ExprArrayComp(ExprArrayComp),927	ExprImport(ExprImport),928	ExprVar(ExprVar),929	ExprLocal(ExprLocal),930	ExprIfThenElse(ExprIfThenElse),931	ExprFunction(ExprFunction),932	ExprAssert(ExprAssert),933	ExprError(ExprError),934}935936#[derive(Debug, Clone, PartialEq, Eq, Hash)]937pub enum ObjBody {938	ObjBodyComp(ObjBodyComp),939	ObjBodyMemberList(ObjBodyMemberList),940}941942#[derive(Debug, Clone, PartialEq, Eq, Hash)]943pub enum CompSpec {944	ForSpec(ForSpec),945	IfSpec(IfSpec),946}947948#[derive(Debug, Clone, PartialEq, Eq, Hash)]949pub enum Bind {950	BindDestruct(BindDestruct),951	BindFunction(BindFunction),952}953954#[derive(Debug, Clone, PartialEq, Eq, Hash)]955pub enum Member {956	MemberBindStmt(MemberBindStmt),957	MemberAssertStmt(MemberAssertStmt),958	MemberField(MemberField),959}960961#[derive(Debug, Clone, PartialEq, Eq, Hash)]962pub enum Field {963	FieldNormal(FieldNormal),964	FieldMethod(FieldMethod),965}966967#[derive(Debug, Clone, PartialEq, Eq, Hash)]968pub enum FieldName {969	FieldNameFixed(FieldNameFixed),970	FieldNameDynamic(FieldNameDynamic),971}972973#[derive(Debug, Clone, PartialEq, Eq, Hash)]974pub enum Destruct {975	DestructFull(DestructFull),976	DestructSkip(DestructSkip),977	DestructArray(DestructArray),978	DestructObject(DestructObject),979}980981#[derive(Debug, Clone, PartialEq, Eq, Hash)]982pub enum DestructArrayPart {983	DestructArrayElement(DestructArrayElement),984	DestructRest(DestructRest),985}986987#[derive(Debug, Clone, PartialEq, Eq, Hash)]988pub struct BinaryOperator {989	syntax: SyntaxToken,990	kind: BinaryOperatorKind,991}992993#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]994pub enum BinaryOperatorKind {995	Or,996	And,997	BitOr,998	BitXor,999	BitAnd,1000	Eq,1001	Ne,1002	Lt,1003	Gt,1004	Le,1005	Ge,1006	InKw,1007	Lhs,1008	Rhs,1009	Plus,1010	Minus,1011	Mul,1012	Div,1013	Modulo,1014	MetaObjectApply,1015	ErrorNoOperator,1016}10171018#[derive(Debug, Clone, PartialEq, Eq, Hash)]1019pub struct UnaryOperator {1020	syntax: SyntaxToken,1021	kind: UnaryOperatorKind,1022}10231024#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]1025pub enum UnaryOperatorKind {1026	Minus,1027	Not,1028	BitNot,1029}10301031#[derive(Debug, Clone, PartialEq, Eq, Hash)]1032pub struct Literal {1033	syntax: SyntaxToken,1034	kind: LiteralKind,1035}10361037#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]1038pub enum LiteralKind {1039	NullKw,1040	TrueKw,1041	FalseKw,1042	SelfKw,1043	Dollar,1044	SuperKw,1045}10461047#[derive(Debug, Clone, PartialEq, Eq, Hash)]1048pub struct Text {1049	syntax: SyntaxToken,1050	kind: TextKind,1051}10521053#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]1054pub enum TextKind {1055	StringDouble,1056	ErrorStringDoubleUnterminated,1057	StringSingle,1058	ErrorStringSingleUnterminated,1059	StringDoubleVerbatim,1060	ErrorStringDoubleVerbatimUnterminated,1061	StringSingleVerbatim,1062	ErrorStringSingleVerbatimUnterminated,1063	ErrorStringVerbatimMissingQuotes,1064	StringBlock,1065	ErrorStringBlockUnexpectedEnd,1066	ErrorStringBlockMissingNewLine,1067	ErrorStringBlockMissingTermination,1068	ErrorStringBlockMissingIndent,1069}10701071#[derive(Debug, Clone, PartialEq, Eq, Hash)]1072pub struct Number {1073	syntax: SyntaxToken,1074	kind: NumberKind,1075}10761077#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]1078pub enum NumberKind {1079	Float,1080	ErrorFloatJunkAfterPoint,1081	ErrorFloatJunkAfterExponent,1082	ErrorFloatJunkAfterExponentSign,1083}10841085#[derive(Debug, Clone, PartialEq, Eq, Hash)]1086pub struct ImportKind {1087	syntax: SyntaxToken,1088	kind: ImportKindKind,1089}10901091#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]1092pub enum ImportKindKind {1093	ImportstrKw,1094	ImportbinKw,1095	ImportKw,1096}10971098#[derive(Debug, Clone, PartialEq, Eq, Hash)]1099pub struct Visibility {1100	syntax: SyntaxToken,1101	kind: VisibilityKind,1102}11031104#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]1105pub enum VisibilityKind {1106	Coloncoloncolon,1107	Coloncolon,1108	Colon,1109}11101111#[derive(Debug, Clone, PartialEq, Eq, Hash)]1112pub struct Trivia {1113	syntax: SyntaxToken,1114	kind: TriviaKind,1115}11161117#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]1118pub enum TriviaKind {1119	Whitespace,1120	MultiLineComment,1121	ErrorCommentTooShort,1122	ErrorCommentUnterminated,1123	SingleLineHashComment,1124	SingleLineSlashComment,1125}11261127#[derive(Debug, Clone, PartialEq, Eq, Hash)]1128pub struct ParsingError {1129	syntax: SyntaxToken,1130	kind: ParsingErrorKind,1131}11321133#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]1134pub enum ParsingErrorKind {1135	ErrorMissingToken,1136	ErrorUnexpectedToken,1137}1138impl AstNode for SourceFile {1139	fn can_cast(kind: SyntaxKind) -> bool {1140		kind == SOURCE_FILE1141	}1142	fn cast(syntax: SyntaxNode) -> Option<Self> {1143		if Self::can_cast(syntax.kind()) {1144			Some(Self { syntax })1145		} else {1146			None1147		}1148	}1149	fn syntax(&self) -> &SyntaxNode {1150		&self.syntax1151	}1152}1153impl AstNode for ExprBinary {1154	fn can_cast(kind: SyntaxKind) -> bool {1155		kind == EXPR_BINARY1156	}1157	fn cast(syntax: SyntaxNode) -> Option<Self> {1158		if Self::can_cast(syntax.kind()) {1159			Some(Self { syntax })1160		} else {1161			None1162		}1163	}1164	fn syntax(&self) -> &SyntaxNode {1165		&self.syntax1166	}1167}1168impl AstNode for LhsExpr {1169	fn can_cast(kind: SyntaxKind) -> bool {1170		kind == LHS_EXPR1171	}1172	fn cast(syntax: SyntaxNode) -> Option<Self> {1173		if Self::can_cast(syntax.kind()) {1174			Some(Self { syntax })1175		} else {1176			None1177		}1178	}1179	fn syntax(&self) -> &SyntaxNode {1180		&self.syntax1181	}1182}1183impl AstNode for ExprUnary {1184	fn can_cast(kind: SyntaxKind) -> bool {1185		kind == EXPR_UNARY1186	}1187	fn cast(syntax: SyntaxNode) -> Option<Self> {1188		if Self::can_cast(syntax.kind()) {1189			Some(Self { syntax })1190		} else {1191			None1192		}1193	}1194	fn syntax(&self) -> &SyntaxNode {1195		&self.syntax1196	}1197}1198impl AstNode for ExprSlice {1199	fn can_cast(kind: SyntaxKind) -> bool {1200		kind == EXPR_SLICE1201	}1202	fn cast(syntax: SyntaxNode) -> Option<Self> {1203		if Self::can_cast(syntax.kind()) {1204			Some(Self { syntax })1205		} else {1206			None1207		}1208	}1209	fn syntax(&self) -> &SyntaxNode {1210		&self.syntax1211	}1212}1213impl AstNode for SliceDesc {1214	fn can_cast(kind: SyntaxKind) -> bool {1215		kind == SLICE_DESC1216	}1217	fn cast(syntax: SyntaxNode) -> Option<Self> {1218		if Self::can_cast(syntax.kind()) {1219			Some(Self { syntax })1220		} else {1221			None1222		}1223	}1224	fn syntax(&self) -> &SyntaxNode {1225		&self.syntax1226	}1227}1228impl AstNode for ExprIndex {1229	fn can_cast(kind: SyntaxKind) -> bool {1230		kind == EXPR_INDEX1231	}1232	fn cast(syntax: SyntaxNode) -> Option<Self> {1233		if Self::can_cast(syntax.kind()) {1234			Some(Self { syntax })1235		} else {1236			None1237		}1238	}1239	fn syntax(&self) -> &SyntaxNode {1240		&self.syntax1241	}1242}1243impl AstNode for Name {1244	fn can_cast(kind: SyntaxKind) -> bool {1245		kind == NAME1246	}1247	fn cast(syntax: SyntaxNode) -> Option<Self> {1248		if Self::can_cast(syntax.kind()) {1249			Some(Self { syntax })1250		} else {1251			None1252		}1253	}1254	fn syntax(&self) -> &SyntaxNode {1255		&self.syntax1256	}1257}1258impl AstNode for ExprIndexExpr {1259	fn can_cast(kind: SyntaxKind) -> bool {1260		kind == EXPR_INDEX_EXPR1261	}1262	fn cast(syntax: SyntaxNode) -> Option<Self> {1263		if Self::can_cast(syntax.kind()) {1264			Some(Self { syntax })1265		} else {1266			None1267		}1268	}1269	fn syntax(&self) -> &SyntaxNode {1270		&self.syntax1271	}1272}1273impl AstNode for ExprApply {1274	fn can_cast(kind: SyntaxKind) -> bool {1275		kind == EXPR_APPLY1276	}1277	fn cast(syntax: SyntaxNode) -> Option<Self> {1278		if Self::can_cast(syntax.kind()) {1279			Some(Self { syntax })1280		} else {1281			None1282		}1283	}1284	fn syntax(&self) -> &SyntaxNode {1285		&self.syntax1286	}1287}1288impl AstNode for ArgsDesc {1289	fn can_cast(kind: SyntaxKind) -> bool {1290		kind == ARGS_DESC1291	}1292	fn cast(syntax: SyntaxNode) -> Option<Self> {1293		if Self::can_cast(syntax.kind()) {1294			Some(Self { syntax })1295		} else {1296			None1297		}1298	}1299	fn syntax(&self) -> &SyntaxNode {1300		&self.syntax1301	}1302}1303impl AstNode for ExprObjExtend {1304	fn can_cast(kind: SyntaxKind) -> bool {1305		kind == EXPR_OBJ_EXTEND1306	}1307	fn cast(syntax: SyntaxNode) -> Option<Self> {1308		if Self::can_cast(syntax.kind()) {1309			Some(Self { syntax })1310		} else {1311			None1312		}1313	}1314	fn syntax(&self) -> &SyntaxNode {1315		&self.syntax1316	}1317}1318impl AstNode for ExprParened {1319	fn can_cast(kind: SyntaxKind) -> bool {1320		kind == EXPR_PARENED1321	}1322	fn cast(syntax: SyntaxNode) -> Option<Self> {1323		if Self::can_cast(syntax.kind()) {1324			Some(Self { syntax })1325		} else {1326			None1327		}1328	}1329	fn syntax(&self) -> &SyntaxNode {1330		&self.syntax1331	}1332}1333impl AstNode for ExprLiteral {1334	fn can_cast(kind: SyntaxKind) -> bool {1335		kind == EXPR_LITERAL1336	}1337	fn cast(syntax: SyntaxNode) -> Option<Self> {1338		if Self::can_cast(syntax.kind()) {1339			Some(Self { syntax })1340		} else {1341			None1342		}1343	}1344	fn syntax(&self) -> &SyntaxNode {1345		&self.syntax1346	}1347}1348impl AstNode for ExprIntrinsicThisFile {1349	fn can_cast(kind: SyntaxKind) -> bool {1350		kind == EXPR_INTRINSIC_THIS_FILE1351	}1352	fn cast(syntax: SyntaxNode) -> Option<Self> {1353		if Self::can_cast(syntax.kind()) {1354			Some(Self { syntax })1355		} else {1356			None1357		}1358	}1359	fn syntax(&self) -> &SyntaxNode {1360		&self.syntax1361	}1362}1363impl AstNode for ExprIntrinsicId {1364	fn can_cast(kind: SyntaxKind) -> bool {1365		kind == EXPR_INTRINSIC_ID1366	}1367	fn cast(syntax: SyntaxNode) -> Option<Self> {1368		if Self::can_cast(syntax.kind()) {1369			Some(Self { syntax })1370		} else {1371			None1372		}1373	}1374	fn syntax(&self) -> &SyntaxNode {1375		&self.syntax1376	}1377}1378impl AstNode for ExprIntrinsic {1379	fn can_cast(kind: SyntaxKind) -> bool {1380		kind == EXPR_INTRINSIC1381	}1382	fn cast(syntax: SyntaxNode) -> Option<Self> {1383		if Self::can_cast(syntax.kind()) {1384			Some(Self { syntax })1385		} else {1386			None1387		}1388	}1389	fn syntax(&self) -> &SyntaxNode {1390		&self.syntax1391	}1392}1393impl AstNode for ExprString {1394	fn can_cast(kind: SyntaxKind) -> bool {1395		kind == EXPR_STRING1396	}1397	fn cast(syntax: SyntaxNode) -> Option<Self> {1398		if Self::can_cast(syntax.kind()) {1399			Some(Self { syntax })1400		} else {1401			None1402		}1403	}1404	fn syntax(&self) -> &SyntaxNode {1405		&self.syntax1406	}1407}1408impl AstNode for ExprNumber {1409	fn can_cast(kind: SyntaxKind) -> bool {1410		kind == EXPR_NUMBER1411	}1412	fn cast(syntax: SyntaxNode) -> Option<Self> {1413		if Self::can_cast(syntax.kind()) {1414			Some(Self { syntax })1415		} else {1416			None1417		}1418	}1419	fn syntax(&self) -> &SyntaxNode {1420		&self.syntax1421	}1422}1423impl AstNode for ExprArray {1424	fn can_cast(kind: SyntaxKind) -> bool {1425		kind == EXPR_ARRAY1426	}1427	fn cast(syntax: SyntaxNode) -> Option<Self> {1428		if Self::can_cast(syntax.kind()) {1429			Some(Self { syntax })1430		} else {1431			None1432		}1433	}1434	fn syntax(&self) -> &SyntaxNode {1435		&self.syntax1436	}1437}1438impl AstNode for ExprObject {1439	fn can_cast(kind: SyntaxKind) -> bool {1440		kind == EXPR_OBJECT1441	}1442	fn cast(syntax: SyntaxNode) -> Option<Self> {1443		if Self::can_cast(syntax.kind()) {1444			Some(Self { syntax })1445		} else {1446			None1447		}1448	}1449	fn syntax(&self) -> &SyntaxNode {1450		&self.syntax1451	}1452}1453impl AstNode for ExprArrayComp {1454	fn can_cast(kind: SyntaxKind) -> bool {1455		kind == EXPR_ARRAY_COMP1456	}1457	fn cast(syntax: SyntaxNode) -> Option<Self> {1458		if Self::can_cast(syntax.kind()) {1459			Some(Self { syntax })1460		} else {1461			None1462		}1463	}1464	fn syntax(&self) -> &SyntaxNode {1465		&self.syntax1466	}1467}1468impl AstNode for ExprImport {1469	fn can_cast(kind: SyntaxKind) -> bool {1470		kind == EXPR_IMPORT1471	}1472	fn cast(syntax: SyntaxNode) -> Option<Self> {1473		if Self::can_cast(syntax.kind()) {1474			Some(Self { syntax })1475		} else {1476			None1477		}1478	}1479	fn syntax(&self) -> &SyntaxNode {1480		&self.syntax1481	}1482}1483impl AstNode for ExprVar {1484	fn can_cast(kind: SyntaxKind) -> bool {1485		kind == EXPR_VAR1486	}1487	fn cast(syntax: SyntaxNode) -> Option<Self> {1488		if Self::can_cast(syntax.kind()) {1489			Some(Self { syntax })1490		} else {1491			None1492		}1493	}1494	fn syntax(&self) -> &SyntaxNode {1495		&self.syntax1496	}1497}1498impl AstNode for ExprLocal {1499	fn can_cast(kind: SyntaxKind) -> bool {1500		kind == EXPR_LOCAL1501	}1502	fn cast(syntax: SyntaxNode) -> Option<Self> {1503		if Self::can_cast(syntax.kind()) {1504			Some(Self { syntax })1505		} else {1506			None1507		}1508	}1509	fn syntax(&self) -> &SyntaxNode {1510		&self.syntax1511	}1512}1513impl AstNode for ExprIfThenElse {1514	fn can_cast(kind: SyntaxKind) -> bool {1515		kind == EXPR_IF_THEN_ELSE1516	}1517	fn cast(syntax: SyntaxNode) -> Option<Self> {1518		if Self::can_cast(syntax.kind()) {1519			Some(Self { syntax })1520		} else {1521			None1522		}1523	}1524	fn syntax(&self) -> &SyntaxNode {1525		&self.syntax1526	}1527}1528impl AstNode for TrueExpr {1529	fn can_cast(kind: SyntaxKind) -> bool {1530		kind == TRUE_EXPR1531	}1532	fn cast(syntax: SyntaxNode) -> Option<Self> {1533		if Self::can_cast(syntax.kind()) {1534			Some(Self { syntax })1535		} else {1536			None1537		}1538	}1539	fn syntax(&self) -> &SyntaxNode {1540		&self.syntax1541	}1542}1543impl AstNode for FalseExpr {1544	fn can_cast(kind: SyntaxKind) -> bool {1545		kind == FALSE_EXPR1546	}1547	fn cast(syntax: SyntaxNode) -> Option<Self> {1548		if Self::can_cast(syntax.kind()) {1549			Some(Self { syntax })1550		} else {1551			None1552		}1553	}1554	fn syntax(&self) -> &SyntaxNode {1555		&self.syntax1556	}1557}1558impl AstNode for ExprFunction {1559	fn can_cast(kind: SyntaxKind) -> bool {1560		kind == EXPR_FUNCTION1561	}1562	fn cast(syntax: SyntaxNode) -> Option<Self> {1563		if Self::can_cast(syntax.kind()) {1564			Some(Self { syntax })1565		} else {1566			None1567		}1568	}1569	fn syntax(&self) -> &SyntaxNode {1570		&self.syntax1571	}1572}1573impl AstNode for ParamsDesc {1574	fn can_cast(kind: SyntaxKind) -> bool {1575		kind == PARAMS_DESC1576	}1577	fn cast(syntax: SyntaxNode) -> Option<Self> {1578		if Self::can_cast(syntax.kind()) {1579			Some(Self { syntax })1580		} else {1581			None1582		}1583	}1584	fn syntax(&self) -> &SyntaxNode {1585		&self.syntax1586	}1587}1588impl AstNode for ExprAssert {1589	fn can_cast(kind: SyntaxKind) -> bool {1590		kind == EXPR_ASSERT1591	}1592	fn cast(syntax: SyntaxNode) -> Option<Self> {1593		if Self::can_cast(syntax.kind()) {1594			Some(Self { syntax })1595		} else {1596			None1597		}1598	}1599	fn syntax(&self) -> &SyntaxNode {1600		&self.syntax1601	}1602}1603impl AstNode for Assertion {1604	fn can_cast(kind: SyntaxKind) -> bool {1605		kind == ASSERTION1606	}1607	fn cast(syntax: SyntaxNode) -> Option<Self> {1608		if Self::can_cast(syntax.kind()) {1609			Some(Self { syntax })1610		} else {1611			None1612		}1613	}1614	fn syntax(&self) -> &SyntaxNode {1615		&self.syntax1616	}1617}1618impl AstNode for ExprError {1619	fn can_cast(kind: SyntaxKind) -> bool {1620		kind == EXPR_ERROR1621	}1622	fn cast(syntax: SyntaxNode) -> Option<Self> {1623		if Self::can_cast(syntax.kind()) {1624			Some(Self { syntax })1625		} else {1626			None1627		}1628	}1629	fn syntax(&self) -> &SyntaxNode {1630		&self.syntax1631	}1632}1633impl AstNode for SliceDescEnd {1634	fn can_cast(kind: SyntaxKind) -> bool {1635		kind == SLICE_DESC_END1636	}1637	fn cast(syntax: SyntaxNode) -> Option<Self> {1638		if Self::can_cast(syntax.kind()) {1639			Some(Self { syntax })1640		} else {1641			None1642		}1643	}1644	fn syntax(&self) -> &SyntaxNode {1645		&self.syntax1646	}1647}1648impl AstNode for SliceDescStep {1649	fn can_cast(kind: SyntaxKind) -> bool {1650		kind == SLICE_DESC_STEP1651	}1652	fn cast(syntax: SyntaxNode) -> Option<Self> {1653		if Self::can_cast(syntax.kind()) {1654			Some(Self { syntax })1655		} else {1656			None1657		}1658	}1659	fn syntax(&self) -> &SyntaxNode {1660		&self.syntax1661	}1662}1663impl AstNode for Arg {1664	fn can_cast(kind: SyntaxKind) -> bool {1665		kind == ARG1666	}1667	fn cast(syntax: SyntaxNode) -> Option<Self> {1668		if Self::can_cast(syntax.kind()) {1669			Some(Self { syntax })1670		} else {1671			None1672		}1673	}1674	fn syntax(&self) -> &SyntaxNode {1675		&self.syntax1676	}1677}1678impl AstNode for ObjBodyComp {1679	fn can_cast(kind: SyntaxKind) -> bool {1680		kind == OBJ_BODY_COMP1681	}1682	fn cast(syntax: SyntaxNode) -> Option<Self> {1683		if Self::can_cast(syntax.kind()) {1684			Some(Self { syntax })1685		} else {1686			None1687		}1688	}1689	fn syntax(&self) -> &SyntaxNode {1690		&self.syntax1691	}1692}1693impl AstNode for ObjLocalPostComma {1694	fn can_cast(kind: SyntaxKind) -> bool {1695		kind == OBJ_LOCAL_POST_COMMA1696	}1697	fn cast(syntax: SyntaxNode) -> Option<Self> {1698		if Self::can_cast(syntax.kind()) {1699			Some(Self { syntax })1700		} else {1701			None1702		}1703	}1704	fn syntax(&self) -> &SyntaxNode {1705		&self.syntax1706	}1707}1708impl AstNode for ObjLocalPreComma {1709	fn can_cast(kind: SyntaxKind) -> bool {1710		kind == OBJ_LOCAL_PRE_COMMA1711	}1712	fn cast(syntax: SyntaxNode) -> Option<Self> {1713		if Self::can_cast(syntax.kind()) {1714			Some(Self { syntax })1715		} else {1716			None1717		}1718	}1719	fn syntax(&self) -> &SyntaxNode {1720		&self.syntax1721	}1722}1723impl AstNode for ObjBodyMemberList {1724	fn can_cast(kind: SyntaxKind) -> bool {1725		kind == OBJ_BODY_MEMBER_LIST1726	}1727	fn cast(syntax: SyntaxNode) -> Option<Self> {1728		if Self::can_cast(syntax.kind()) {1729			Some(Self { syntax })1730		} else {1731			None1732		}1733	}1734	fn syntax(&self) -> &SyntaxNode {1735		&self.syntax1736	}1737}1738impl AstNode for ObjLocal {1739	fn can_cast(kind: SyntaxKind) -> bool {1740		kind == OBJ_LOCAL1741	}1742	fn cast(syntax: SyntaxNode) -> Option<Self> {1743		if Self::can_cast(syntax.kind()) {1744			Some(Self { syntax })1745		} else {1746			None1747		}1748	}1749	fn syntax(&self) -> &SyntaxNode {1750		&self.syntax1751	}1752}1753impl AstNode for MemberBindStmt {1754	fn can_cast(kind: SyntaxKind) -> bool {1755		kind == MEMBER_BIND_STMT1756	}1757	fn cast(syntax: SyntaxNode) -> Option<Self> {1758		if Self::can_cast(syntax.kind()) {1759			Some(Self { syntax })1760		} else {1761			None1762		}1763	}1764	fn syntax(&self) -> &SyntaxNode {1765		&self.syntax1766	}1767}1768impl AstNode for MemberAssertStmt {1769	fn can_cast(kind: SyntaxKind) -> bool {1770		kind == MEMBER_ASSERT_STMT1771	}1772	fn cast(syntax: SyntaxNode) -> Option<Self> {1773		if Self::can_cast(syntax.kind()) {1774			Some(Self { syntax })1775		} else {1776			None1777		}1778	}1779	fn syntax(&self) -> &SyntaxNode {1780		&self.syntax1781	}1782}1783impl AstNode for MemberField {1784	fn can_cast(kind: SyntaxKind) -> bool {1785		kind == MEMBER_FIELD1786	}1787	fn cast(syntax: SyntaxNode) -> Option<Self> {1788		if Self::can_cast(syntax.kind()) {1789			Some(Self { syntax })1790		} else {1791			None1792		}1793	}1794	fn syntax(&self) -> &SyntaxNode {1795		&self.syntax1796	}1797}1798impl AstNode for FieldNormal {1799	fn can_cast(kind: SyntaxKind) -> bool {1800		kind == FIELD_NORMAL1801	}1802	fn cast(syntax: SyntaxNode) -> Option<Self> {1803		if Self::can_cast(syntax.kind()) {1804			Some(Self { syntax })1805		} else {1806			None1807		}1808	}1809	fn syntax(&self) -> &SyntaxNode {1810		&self.syntax1811	}1812}1813impl AstNode for FieldMethod {1814	fn can_cast(kind: SyntaxKind) -> bool {1815		kind == FIELD_METHOD1816	}1817	fn cast(syntax: SyntaxNode) -> Option<Self> {1818		if Self::can_cast(syntax.kind()) {1819			Some(Self { syntax })1820		} else {1821			None1822		}1823	}1824	fn syntax(&self) -> &SyntaxNode {1825		&self.syntax1826	}1827}1828impl AstNode for FieldNameFixed {1829	fn can_cast(kind: SyntaxKind) -> bool {1830		kind == FIELD_NAME_FIXED1831	}1832	fn cast(syntax: SyntaxNode) -> Option<Self> {1833		if Self::can_cast(syntax.kind()) {1834			Some(Self { syntax })1835		} else {1836			None1837		}1838	}1839	fn syntax(&self) -> &SyntaxNode {1840		&self.syntax1841	}1842}1843impl AstNode for FieldNameDynamic {1844	fn can_cast(kind: SyntaxKind) -> bool {1845		kind == FIELD_NAME_DYNAMIC1846	}1847	fn cast(syntax: SyntaxNode) -> Option<Self> {1848		if Self::can_cast(syntax.kind()) {1849			Some(Self { syntax })1850		} else {1851			None1852		}1853	}1854	fn syntax(&self) -> &SyntaxNode {1855		&self.syntax1856	}1857}1858impl AstNode for ForSpec {1859	fn can_cast(kind: SyntaxKind) -> bool {1860		kind == FOR_SPEC1861	}1862	fn cast(syntax: SyntaxNode) -> Option<Self> {1863		if Self::can_cast(syntax.kind()) {1864			Some(Self { syntax })1865		} else {1866			None1867		}1868	}1869	fn syntax(&self) -> &SyntaxNode {1870		&self.syntax1871	}1872}1873impl AstNode for IfSpec {1874	fn can_cast(kind: SyntaxKind) -> bool {1875		kind == IF_SPEC1876	}1877	fn cast(syntax: SyntaxNode) -> Option<Self> {1878		if Self::can_cast(syntax.kind()) {1879			Some(Self { syntax })1880		} else {1881			None1882		}1883	}1884	fn syntax(&self) -> &SyntaxNode {1885		&self.syntax1886	}1887}1888impl AstNode for BindDestruct {1889	fn can_cast(kind: SyntaxKind) -> bool {1890		kind == BIND_DESTRUCT1891	}1892	fn cast(syntax: SyntaxNode) -> Option<Self> {1893		if Self::can_cast(syntax.kind()) {1894			Some(Self { syntax })1895		} else {1896			None1897		}1898	}1899	fn syntax(&self) -> &SyntaxNode {1900		&self.syntax1901	}1902}1903impl AstNode for BindFunction {1904	fn can_cast(kind: SyntaxKind) -> bool {1905		kind == BIND_FUNCTION1906	}1907	fn cast(syntax: SyntaxNode) -> Option<Self> {1908		if Self::can_cast(syntax.kind()) {1909			Some(Self { syntax })1910		} else {1911			None1912		}1913	}1914	fn syntax(&self) -> &SyntaxNode {1915		&self.syntax1916	}1917}1918impl AstNode for Param {1919	fn can_cast(kind: SyntaxKind) -> bool {1920		kind == PARAM1921	}1922	fn cast(syntax: SyntaxNode) -> Option<Self> {1923		if Self::can_cast(syntax.kind()) {1924			Some(Self { syntax })1925		} else {1926			None1927		}1928	}1929	fn syntax(&self) -> &SyntaxNode {1930		&self.syntax1931	}1932}1933impl AstNode for DestructFull {1934	fn can_cast(kind: SyntaxKind) -> bool {1935		kind == DESTRUCT_FULL1936	}1937	fn cast(syntax: SyntaxNode) -> Option<Self> {1938		if Self::can_cast(syntax.kind()) {1939			Some(Self { syntax })1940		} else {1941			None1942		}1943	}1944	fn syntax(&self) -> &SyntaxNode {1945		&self.syntax1946	}1947}1948impl AstNode for DestructSkip {1949	fn can_cast(kind: SyntaxKind) -> bool {1950		kind == DESTRUCT_SKIP1951	}1952	fn cast(syntax: SyntaxNode) -> Option<Self> {1953		if Self::can_cast(syntax.kind()) {1954			Some(Self { syntax })1955		} else {1956			None1957		}1958	}1959	fn syntax(&self) -> &SyntaxNode {1960		&self.syntax1961	}1962}1963impl AstNode for DestructArray {1964	fn can_cast(kind: SyntaxKind) -> bool {1965		kind == DESTRUCT_ARRAY1966	}1967	fn cast(syntax: SyntaxNode) -> Option<Self> {1968		if Self::can_cast(syntax.kind()) {1969			Some(Self { syntax })1970		} else {1971			None1972		}1973	}1974	fn syntax(&self) -> &SyntaxNode {1975		&self.syntax1976	}1977}1978impl AstNode for DestructObject {1979	fn can_cast(kind: SyntaxKind) -> bool {1980		kind == DESTRUCT_OBJECT1981	}1982	fn cast(syntax: SyntaxNode) -> Option<Self> {1983		if Self::can_cast(syntax.kind()) {1984			Some(Self { syntax })1985		} else {1986			None1987		}1988	}1989	fn syntax(&self) -> &SyntaxNode {1990		&self.syntax1991	}1992}1993impl AstNode for DestructObjectField {1994	fn can_cast(kind: SyntaxKind) -> bool {1995		kind == DESTRUCT_OBJECT_FIELD1996	}1997	fn cast(syntax: SyntaxNode) -> Option<Self> {1998		if Self::can_cast(syntax.kind()) {1999			Some(Self { syntax })2000		} else {2001			None2002		}2003	}2004	fn syntax(&self) -> &SyntaxNode {2005		&self.syntax2006	}2007}2008impl AstNode for DestructRest {2009	fn can_cast(kind: SyntaxKind) -> bool {2010		kind == DESTRUCT_REST2011	}2012	fn cast(syntax: SyntaxNode) -> Option<Self> {2013		if Self::can_cast(syntax.kind()) {2014			Some(Self { syntax })2015		} else {2016			None2017		}2018	}2019	fn syntax(&self) -> &SyntaxNode {2020		&self.syntax2021	}2022}2023impl AstNode for DestructArrayElement {2024	fn can_cast(kind: SyntaxKind) -> bool {2025		kind == DESTRUCT_ARRAY_ELEMENT2026	}2027	fn cast(syntax: SyntaxNode) -> Option<Self> {2028		if Self::can_cast(syntax.kind()) {2029			Some(Self { syntax })2030		} else {2031			None2032		}2033	}2034	fn syntax(&self) -> &SyntaxNode {2035		&self.syntax2036	}2037}2038impl From<ExprBinary> for Expr {2039	fn from(node: ExprBinary) -> Expr {2040		Expr::ExprBinary(node)2041	}2042}2043impl From<ExprUnary> for Expr {2044	fn from(node: ExprUnary) -> Expr {2045		Expr::ExprUnary(node)2046	}2047}2048impl From<ExprSlice> for Expr {2049	fn from(node: ExprSlice) -> Expr {2050		Expr::ExprSlice(node)2051	}2052}2053impl From<ExprIndex> for Expr {2054	fn from(node: ExprIndex) -> Expr {2055		Expr::ExprIndex(node)2056	}2057}2058impl From<ExprIndexExpr> for Expr {2059	fn from(node: ExprIndexExpr) -> Expr {2060		Expr::ExprIndexExpr(node)2061	}2062}2063impl From<ExprApply> for Expr {2064	fn from(node: ExprApply) -> Expr {2065		Expr::ExprApply(node)2066	}2067}2068impl From<ExprObjExtend> for Expr {2069	fn from(node: ExprObjExtend) -> Expr {2070		Expr::ExprObjExtend(node)2071	}2072}2073impl From<ExprParened> for Expr {2074	fn from(node: ExprParened) -> Expr {2075		Expr::ExprParened(node)2076	}2077}2078impl From<ExprIntrinsicThisFile> for Expr {2079	fn from(node: ExprIntrinsicThisFile) -> Expr {2080		Expr::ExprIntrinsicThisFile(node)2081	}2082}2083impl From<ExprIntrinsicId> for Expr {2084	fn from(node: ExprIntrinsicId) -> Expr {2085		Expr::ExprIntrinsicId(node)2086	}2087}2088impl From<ExprIntrinsic> for Expr {2089	fn from(node: ExprIntrinsic) -> Expr {2090		Expr::ExprIntrinsic(node)2091	}2092}2093impl From<ExprString> for Expr {2094	fn from(node: ExprString) -> Expr {2095		Expr::ExprString(node)2096	}2097}2098impl From<ExprNumber> for Expr {2099	fn from(node: ExprNumber) -> Expr {2100		Expr::ExprNumber(node)2101	}2102}2103impl From<ExprLiteral> for Expr {2104	fn from(node: ExprLiteral) -> Expr {2105		Expr::ExprLiteral(node)2106	}2107}2108impl From<ExprArray> for Expr {2109	fn from(node: ExprArray) -> Expr {2110		Expr::ExprArray(node)2111	}2112}2113impl From<ExprObject> for Expr {2114	fn from(node: ExprObject) -> Expr {2115		Expr::ExprObject(node)2116	}2117}2118impl From<ExprArrayComp> for Expr {2119	fn from(node: ExprArrayComp) -> Expr {2120		Expr::ExprArrayComp(node)2121	}2122}2123impl From<ExprImport> for Expr {2124	fn from(node: ExprImport) -> Expr {2125		Expr::ExprImport(node)2126	}2127}2128impl From<ExprVar> for Expr {2129	fn from(node: ExprVar) -> Expr {2130		Expr::ExprVar(node)2131	}2132}2133impl From<ExprLocal> for Expr {2134	fn from(node: ExprLocal) -> Expr {2135		Expr::ExprLocal(node)2136	}2137}2138impl From<ExprIfThenElse> for Expr {2139	fn from(node: ExprIfThenElse) -> Expr {2140		Expr::ExprIfThenElse(node)2141	}2142}2143impl From<ExprFunction> for Expr {2144	fn from(node: ExprFunction) -> Expr {2145		Expr::ExprFunction(node)2146	}2147}2148impl From<ExprAssert> for Expr {2149	fn from(node: ExprAssert) -> Expr {2150		Expr::ExprAssert(node)2151	}2152}2153impl From<ExprError> for Expr {2154	fn from(node: ExprError) -> Expr {2155		Expr::ExprError(node)2156	}2157}2158impl AstNode for Expr {2159	fn can_cast(kind: SyntaxKind) -> bool {2160		match kind {2161			EXPR_BINARY2162			| EXPR_UNARY2163			| EXPR_SLICE2164			| EXPR_INDEX2165			| EXPR_INDEX_EXPR2166			| EXPR_APPLY2167			| EXPR_OBJ_EXTEND2168			| EXPR_PARENED2169			| EXPR_INTRINSIC_THIS_FILE2170			| EXPR_INTRINSIC_ID2171			| EXPR_INTRINSIC2172			| EXPR_STRING2173			| EXPR_NUMBER2174			| EXPR_LITERAL2175			| EXPR_ARRAY2176			| EXPR_OBJECT2177			| EXPR_ARRAY_COMP2178			| EXPR_IMPORT2179			| EXPR_VAR2180			| EXPR_LOCAL2181			| EXPR_IF_THEN_ELSE2182			| EXPR_FUNCTION2183			| EXPR_ASSERT2184			| EXPR_ERROR => true,2185			_ => false,2186		}2187	}2188	fn cast(syntax: SyntaxNode) -> Option<Self> {2189		let res = match syntax.kind() {2190			EXPR_BINARY => Expr::ExprBinary(ExprBinary { syntax }),2191			EXPR_UNARY => Expr::ExprUnary(ExprUnary { syntax }),2192			EXPR_SLICE => Expr::ExprSlice(ExprSlice { syntax }),2193			EXPR_INDEX => Expr::ExprIndex(ExprIndex { syntax }),2194			EXPR_INDEX_EXPR => Expr::ExprIndexExpr(ExprIndexExpr { syntax }),2195			EXPR_APPLY => Expr::ExprApply(ExprApply { syntax }),2196			EXPR_OBJ_EXTEND => Expr::ExprObjExtend(ExprObjExtend { syntax }),2197			EXPR_PARENED => Expr::ExprParened(ExprParened { syntax }),2198			EXPR_INTRINSIC_THIS_FILE => {2199				Expr::ExprIntrinsicThisFile(ExprIntrinsicThisFile { syntax })2200			}2201			EXPR_INTRINSIC_ID => Expr::ExprIntrinsicId(ExprIntrinsicId { syntax }),2202			EXPR_INTRINSIC => Expr::ExprIntrinsic(ExprIntrinsic { syntax }),2203			EXPR_STRING => Expr::ExprString(ExprString { syntax }),2204			EXPR_NUMBER => Expr::ExprNumber(ExprNumber { syntax }),2205			EXPR_LITERAL => Expr::ExprLiteral(ExprLiteral { syntax }),2206			EXPR_ARRAY => Expr::ExprArray(ExprArray { syntax }),2207			EXPR_OBJECT => Expr::ExprObject(ExprObject { syntax }),2208			EXPR_ARRAY_COMP => Expr::ExprArrayComp(ExprArrayComp { syntax }),2209			EXPR_IMPORT => Expr::ExprImport(ExprImport { syntax }),2210			EXPR_VAR => Expr::ExprVar(ExprVar { syntax }),2211			EXPR_LOCAL => Expr::ExprLocal(ExprLocal { syntax }),2212			EXPR_IF_THEN_ELSE => Expr::ExprIfThenElse(ExprIfThenElse { syntax }),2213			EXPR_FUNCTION => Expr::ExprFunction(ExprFunction { syntax }),2214			EXPR_ASSERT => Expr::ExprAssert(ExprAssert { syntax }),2215			EXPR_ERROR => Expr::ExprError(ExprError { syntax }),2216			_ => return None,2217		};2218		Some(res)2219	}2220	fn syntax(&self) -> &SyntaxNode {2221		match self {2222			Expr::ExprBinary(it) => &it.syntax,2223			Expr::ExprUnary(it) => &it.syntax,2224			Expr::ExprSlice(it) => &it.syntax,2225			Expr::ExprIndex(it) => &it.syntax,2226			Expr::ExprIndexExpr(it) => &it.syntax,2227			Expr::ExprApply(it) => &it.syntax,2228			Expr::ExprObjExtend(it) => &it.syntax,2229			Expr::ExprParened(it) => &it.syntax,2230			Expr::ExprIntrinsicThisFile(it) => &it.syntax,2231			Expr::ExprIntrinsicId(it) => &it.syntax,2232			Expr::ExprIntrinsic(it) => &it.syntax,2233			Expr::ExprString(it) => &it.syntax,2234			Expr::ExprNumber(it) => &it.syntax,2235			Expr::ExprLiteral(it) => &it.syntax,2236			Expr::ExprArray(it) => &it.syntax,2237			Expr::ExprObject(it) => &it.syntax,2238			Expr::ExprArrayComp(it) => &it.syntax,2239			Expr::ExprImport(it) => &it.syntax,2240			Expr::ExprVar(it) => &it.syntax,2241			Expr::ExprLocal(it) => &it.syntax,2242			Expr::ExprIfThenElse(it) => &it.syntax,2243			Expr::ExprFunction(it) => &it.syntax,2244			Expr::ExprAssert(it) => &it.syntax,2245			Expr::ExprError(it) => &it.syntax,2246		}2247	}2248}2249impl From<ObjBodyComp> for ObjBody {2250	fn from(node: ObjBodyComp) -> ObjBody {2251		ObjBody::ObjBodyComp(node)2252	}2253}2254impl From<ObjBodyMemberList> for ObjBody {2255	fn from(node: ObjBodyMemberList) -> ObjBody {2256		ObjBody::ObjBodyMemberList(node)2257	}2258}2259impl AstNode for ObjBody {2260	fn can_cast(kind: SyntaxKind) -> bool {2261		match kind {2262			OBJ_BODY_COMP | OBJ_BODY_MEMBER_LIST => true,2263			_ => false,2264		}2265	}2266	fn cast(syntax: SyntaxNode) -> Option<Self> {2267		let res = match syntax.kind() {2268			OBJ_BODY_COMP => ObjBody::ObjBodyComp(ObjBodyComp { syntax }),2269			OBJ_BODY_MEMBER_LIST => ObjBody::ObjBodyMemberList(ObjBodyMemberList { syntax }),2270			_ => return None,2271		};2272		Some(res)2273	}2274	fn syntax(&self) -> &SyntaxNode {2275		match self {2276			ObjBody::ObjBodyComp(it) => &it.syntax,2277			ObjBody::ObjBodyMemberList(it) => &it.syntax,2278		}2279	}2280}2281impl From<ForSpec> for CompSpec {2282	fn from(node: ForSpec) -> CompSpec {2283		CompSpec::ForSpec(node)2284	}2285}2286impl From<IfSpec> for CompSpec {2287	fn from(node: IfSpec) -> CompSpec {2288		CompSpec::IfSpec(node)2289	}2290}2291impl AstNode for CompSpec {2292	fn can_cast(kind: SyntaxKind) -> bool {2293		match kind {2294			FOR_SPEC | IF_SPEC => true,2295			_ => false,2296		}2297	}2298	fn cast(syntax: SyntaxNode) -> Option<Self> {2299		let res = match syntax.kind() {2300			FOR_SPEC => CompSpec::ForSpec(ForSpec { syntax }),2301			IF_SPEC => CompSpec::IfSpec(IfSpec { syntax }),2302			_ => return None,2303		};2304		Some(res)2305	}2306	fn syntax(&self) -> &SyntaxNode {2307		match self {2308			CompSpec::ForSpec(it) => &it.syntax,2309			CompSpec::IfSpec(it) => &it.syntax,2310		}2311	}2312}2313impl From<BindDestruct> for Bind {2314	fn from(node: BindDestruct) -> Bind {2315		Bind::BindDestruct(node)2316	}2317}2318impl From<BindFunction> for Bind {2319	fn from(node: BindFunction) -> Bind {2320		Bind::BindFunction(node)2321	}2322}2323impl AstNode for Bind {2324	fn can_cast(kind: SyntaxKind) -> bool {2325		match kind {2326			BIND_DESTRUCT | BIND_FUNCTION => true,2327			_ => false,2328		}2329	}2330	fn cast(syntax: SyntaxNode) -> Option<Self> {2331		let res = match syntax.kind() {2332			BIND_DESTRUCT => Bind::BindDestruct(BindDestruct { syntax }),2333			BIND_FUNCTION => Bind::BindFunction(BindFunction { syntax }),2334			_ => return None,2335		};2336		Some(res)2337	}2338	fn syntax(&self) -> &SyntaxNode {2339		match self {2340			Bind::BindDestruct(it) => &it.syntax,2341			Bind::BindFunction(it) => &it.syntax,2342		}2343	}2344}2345impl From<MemberBindStmt> for Member {2346	fn from(node: MemberBindStmt) -> Member {2347		Member::MemberBindStmt(node)2348	}2349}2350impl From<MemberAssertStmt> for Member {2351	fn from(node: MemberAssertStmt) -> Member {2352		Member::MemberAssertStmt(node)2353	}2354}2355impl From<MemberField> for Member {2356	fn from(node: MemberField) -> Member {2357		Member::MemberField(node)2358	}2359}2360impl AstNode for Member {2361	fn can_cast(kind: SyntaxKind) -> bool {2362		match kind {2363			MEMBER_BIND_STMT | MEMBER_ASSERT_STMT | MEMBER_FIELD => true,2364			_ => false,2365		}2366	}2367	fn cast(syntax: SyntaxNode) -> Option<Self> {2368		let res = match syntax.kind() {2369			MEMBER_BIND_STMT => Member::MemberBindStmt(MemberBindStmt { syntax }),2370			MEMBER_ASSERT_STMT => Member::MemberAssertStmt(MemberAssertStmt { syntax }),2371			MEMBER_FIELD => Member::MemberField(MemberField { syntax }),2372			_ => return None,2373		};2374		Some(res)2375	}2376	fn syntax(&self) -> &SyntaxNode {2377		match self {2378			Member::MemberBindStmt(it) => &it.syntax,2379			Member::MemberAssertStmt(it) => &it.syntax,2380			Member::MemberField(it) => &it.syntax,2381		}2382	}2383}2384impl From<FieldNormal> for Field {2385	fn from(node: FieldNormal) -> Field {2386		Field::FieldNormal(node)2387	}2388}2389impl From<FieldMethod> for Field {2390	fn from(node: FieldMethod) -> Field {2391		Field::FieldMethod(node)2392	}2393}2394impl AstNode for Field {2395	fn can_cast(kind: SyntaxKind) -> bool {2396		match kind {2397			FIELD_NORMAL | FIELD_METHOD => true,2398			_ => false,2399		}2400	}2401	fn cast(syntax: SyntaxNode) -> Option<Self> {2402		let res = match syntax.kind() {2403			FIELD_NORMAL => Field::FieldNormal(FieldNormal { syntax }),2404			FIELD_METHOD => Field::FieldMethod(FieldMethod { syntax }),2405			_ => return None,2406		};2407		Some(res)2408	}2409	fn syntax(&self) -> &SyntaxNode {2410		match self {2411			Field::FieldNormal(it) => &it.syntax,2412			Field::FieldMethod(it) => &it.syntax,2413		}2414	}2415}2416impl From<FieldNameFixed> for FieldName {2417	fn from(node: FieldNameFixed) -> FieldName {2418		FieldName::FieldNameFixed(node)2419	}2420}2421impl From<FieldNameDynamic> for FieldName {2422	fn from(node: FieldNameDynamic) -> FieldName {2423		FieldName::FieldNameDynamic(node)2424	}2425}2426impl AstNode for FieldName {2427	fn can_cast(kind: SyntaxKind) -> bool {2428		match kind {2429			FIELD_NAME_FIXED | FIELD_NAME_DYNAMIC => true,2430			_ => false,2431		}2432	}2433	fn cast(syntax: SyntaxNode) -> Option<Self> {2434		let res = match syntax.kind() {2435			FIELD_NAME_FIXED => FieldName::FieldNameFixed(FieldNameFixed { syntax }),2436			FIELD_NAME_DYNAMIC => FieldName::FieldNameDynamic(FieldNameDynamic { syntax }),2437			_ => return None,2438		};2439		Some(res)2440	}2441	fn syntax(&self) -> &SyntaxNode {2442		match self {2443			FieldName::FieldNameFixed(it) => &it.syntax,2444			FieldName::FieldNameDynamic(it) => &it.syntax,2445		}2446	}2447}2448impl From<DestructFull> for Destruct {2449	fn from(node: DestructFull) -> Destruct {2450		Destruct::DestructFull(node)2451	}2452}2453impl From<DestructSkip> for Destruct {2454	fn from(node: DestructSkip) -> Destruct {2455		Destruct::DestructSkip(node)2456	}2457}2458impl From<DestructArray> for Destruct {2459	fn from(node: DestructArray) -> Destruct {2460		Destruct::DestructArray(node)2461	}2462}2463impl From<DestructObject> for Destruct {2464	fn from(node: DestructObject) -> Destruct {2465		Destruct::DestructObject(node)2466	}2467}2468impl AstNode for Destruct {2469	fn can_cast(kind: SyntaxKind) -> bool {2470		match kind {2471			DESTRUCT_FULL | DESTRUCT_SKIP | DESTRUCT_ARRAY | DESTRUCT_OBJECT => true,2472			_ => false,2473		}2474	}2475	fn cast(syntax: SyntaxNode) -> Option<Self> {2476		let res = match syntax.kind() {2477			DESTRUCT_FULL => Destruct::DestructFull(DestructFull { syntax }),2478			DESTRUCT_SKIP => Destruct::DestructSkip(DestructSkip { syntax }),2479			DESTRUCT_ARRAY => Destruct::DestructArray(DestructArray { syntax }),2480			DESTRUCT_OBJECT => Destruct::DestructObject(DestructObject { syntax }),2481			_ => return None,2482		};2483		Some(res)2484	}2485	fn syntax(&self) -> &SyntaxNode {2486		match self {2487			Destruct::DestructFull(it) => &it.syntax,2488			Destruct::DestructSkip(it) => &it.syntax,2489			Destruct::DestructArray(it) => &it.syntax,2490			Destruct::DestructObject(it) => &it.syntax,2491		}2492	}2493}2494impl From<DestructArrayElement> for DestructArrayPart {2495	fn from(node: DestructArrayElement) -> DestructArrayPart {2496		DestructArrayPart::DestructArrayElement(node)2497	}2498}2499impl From<DestructRest> for DestructArrayPart {2500	fn from(node: DestructRest) -> DestructArrayPart {2501		DestructArrayPart::DestructRest(node)2502	}2503}2504impl AstNode for DestructArrayPart {2505	fn can_cast(kind: SyntaxKind) -> bool {2506		match kind {2507			DESTRUCT_ARRAY_ELEMENT | DESTRUCT_REST => true,2508			_ => false,2509		}2510	}2511	fn cast(syntax: SyntaxNode) -> Option<Self> {2512		let res = match syntax.kind() {2513			DESTRUCT_ARRAY_ELEMENT => {2514				DestructArrayPart::DestructArrayElement(DestructArrayElement { syntax })2515			}2516			DESTRUCT_REST => DestructArrayPart::DestructRest(DestructRest { syntax }),2517			_ => return None,2518		};2519		Some(res)2520	}2521	fn syntax(&self) -> &SyntaxNode {2522		match self {2523			DestructArrayPart::DestructArrayElement(it) => &it.syntax,2524			DestructArrayPart::DestructRest(it) => &it.syntax,2525		}2526	}2527}2528impl AstToken for BinaryOperator {2529	fn can_cast(kind: SyntaxKind) -> bool {2530		BinaryOperatorKind::can_cast(kind)2531	}2532	fn cast(syntax: SyntaxToken) -> Option<Self> {2533		let kind = BinaryOperatorKind::cast(syntax.kind())?;2534		Some(BinaryOperator { syntax, kind })2535	}2536	fn syntax(&self) -> &SyntaxToken {2537		&self.syntax2538	}2539}2540impl BinaryOperatorKind {2541	fn can_cast(kind: SyntaxKind) -> bool {2542		match kind {2543			OR | AND | BIT_OR | BIT_XOR | BIT_AND | EQ | NE | LT | GT | LE | GE | IN_KW | LHS2544			| RHS | PLUS | MINUS | MUL | DIV | MODULO | META_OBJECT_APPLY | ERROR_NO_OPERATOR => true,2545			_ => false,2546		}2547	}2548	pub fn cast(kind: SyntaxKind) -> Option<Self> {2549		let res = match kind {2550			OR => Self::Or,2551			AND => Self::And,2552			BIT_OR => Self::BitOr,2553			BIT_XOR => Self::BitXor,2554			BIT_AND => Self::BitAnd,2555			EQ => Self::Eq,2556			NE => Self::Ne,2557			LT => Self::Lt,2558			GT => Self::Gt,2559			LE => Self::Le,2560			GE => Self::Ge,2561			IN_KW => Self::InKw,2562			LHS => Self::Lhs,2563			RHS => Self::Rhs,2564			PLUS => Self::Plus,2565			MINUS => Self::Minus,2566			MUL => Self::Mul,2567			DIV => Self::Div,2568			MODULO => Self::Modulo,2569			META_OBJECT_APPLY => Self::MetaObjectApply,2570			ERROR_NO_OPERATOR => Self::ErrorNoOperator,2571			_ => return None,2572		};2573		Some(res)2574	}2575}2576impl BinaryOperator {2577	pub fn kind(&self) -> BinaryOperatorKind {2578		self.kind2579	}2580}2581impl std::fmt::Display for BinaryOperator {2582	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2583		std::fmt::Display::fmt(self.syntax(), f)2584	}2585}2586impl AstToken for UnaryOperator {2587	fn can_cast(kind: SyntaxKind) -> bool {2588		UnaryOperatorKind::can_cast(kind)2589	}2590	fn cast(syntax: SyntaxToken) -> Option<Self> {2591		let kind = UnaryOperatorKind::cast(syntax.kind())?;2592		Some(UnaryOperator { syntax, kind })2593	}2594	fn syntax(&self) -> &SyntaxToken {2595		&self.syntax2596	}2597}2598impl UnaryOperatorKind {2599	fn can_cast(kind: SyntaxKind) -> bool {2600		match kind {2601			MINUS | NOT | BIT_NOT => true,2602			_ => false,2603		}2604	}2605	pub fn cast(kind: SyntaxKind) -> Option<Self> {2606		let res = match kind {2607			MINUS => Self::Minus,2608			NOT => Self::Not,2609			BIT_NOT => Self::BitNot,2610			_ => return None,2611		};2612		Some(res)2613	}2614}2615impl UnaryOperator {2616	pub fn kind(&self) -> UnaryOperatorKind {2617		self.kind2618	}2619}2620impl std::fmt::Display for UnaryOperator {2621	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2622		std::fmt::Display::fmt(self.syntax(), f)2623	}2624}2625impl AstToken for Literal {2626	fn can_cast(kind: SyntaxKind) -> bool {2627		LiteralKind::can_cast(kind)2628	}2629	fn cast(syntax: SyntaxToken) -> Option<Self> {2630		let kind = LiteralKind::cast(syntax.kind())?;2631		Some(Literal { syntax, kind })2632	}2633	fn syntax(&self) -> &SyntaxToken {2634		&self.syntax2635	}2636}2637impl LiteralKind {2638	fn can_cast(kind: SyntaxKind) -> bool {2639		match kind {2640			NULL_KW | TRUE_KW | FALSE_KW | SELF_KW | DOLLAR | SUPER_KW => true,2641			_ => false,2642		}2643	}2644	pub fn cast(kind: SyntaxKind) -> Option<Self> {2645		let res = match kind {2646			NULL_KW => Self::NullKw,2647			TRUE_KW => Self::TrueKw,2648			FALSE_KW => Self::FalseKw,2649			SELF_KW => Self::SelfKw,2650			DOLLAR => Self::Dollar,2651			SUPER_KW => Self::SuperKw,2652			_ => return None,2653		};2654		Some(res)2655	}2656}2657impl Literal {2658	pub fn kind(&self) -> LiteralKind {2659		self.kind2660	}2661}2662impl std::fmt::Display for Literal {2663	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2664		std::fmt::Display::fmt(self.syntax(), f)2665	}2666}2667impl AstToken for Text {2668	fn can_cast(kind: SyntaxKind) -> bool {2669		TextKind::can_cast(kind)2670	}2671	fn cast(syntax: SyntaxToken) -> Option<Self> {2672		let kind = TextKind::cast(syntax.kind())?;2673		Some(Text { syntax, kind })2674	}2675	fn syntax(&self) -> &SyntaxToken {2676		&self.syntax2677	}2678}2679impl TextKind {2680	fn can_cast(kind: SyntaxKind) -> bool {2681		match kind {2682			STRING_DOUBLE2683			| ERROR_STRING_DOUBLE_UNTERMINATED2684			| STRING_SINGLE2685			| ERROR_STRING_SINGLE_UNTERMINATED2686			| STRING_DOUBLE_VERBATIM2687			| ERROR_STRING_DOUBLE_VERBATIM_UNTERMINATED2688			| STRING_SINGLE_VERBATIM2689			| ERROR_STRING_SINGLE_VERBATIM_UNTERMINATED2690			| ERROR_STRING_VERBATIM_MISSING_QUOTES2691			| STRING_BLOCK2692			| ERROR_STRING_BLOCK_UNEXPECTED_END2693			| ERROR_STRING_BLOCK_MISSING_NEW_LINE2694			| ERROR_STRING_BLOCK_MISSING_TERMINATION2695			| ERROR_STRING_BLOCK_MISSING_INDENT => true,2696			_ => false,2697		}2698	}2699	pub fn cast(kind: SyntaxKind) -> Option<Self> {2700		let res = match kind {2701			STRING_DOUBLE => Self::StringDouble,2702			ERROR_STRING_DOUBLE_UNTERMINATED => Self::ErrorStringDoubleUnterminated,2703			STRING_SINGLE => Self::StringSingle,2704			ERROR_STRING_SINGLE_UNTERMINATED => Self::ErrorStringSingleUnterminated,2705			STRING_DOUBLE_VERBATIM => Self::StringDoubleVerbatim,2706			ERROR_STRING_DOUBLE_VERBATIM_UNTERMINATED => {2707				Self::ErrorStringDoubleVerbatimUnterminated2708			}2709			STRING_SINGLE_VERBATIM => Self::StringSingleVerbatim,2710			ERROR_STRING_SINGLE_VERBATIM_UNTERMINATED => {2711				Self::ErrorStringSingleVerbatimUnterminated2712			}2713			ERROR_STRING_VERBATIM_MISSING_QUOTES => Self::ErrorStringVerbatimMissingQuotes,2714			STRING_BLOCK => Self::StringBlock,2715			ERROR_STRING_BLOCK_UNEXPECTED_END => Self::ErrorStringBlockUnexpectedEnd,2716			ERROR_STRING_BLOCK_MISSING_NEW_LINE => Self::ErrorStringBlockMissingNewLine,2717			ERROR_STRING_BLOCK_MISSING_TERMINATION => Self::ErrorStringBlockMissingTermination,2718			ERROR_STRING_BLOCK_MISSING_INDENT => Self::ErrorStringBlockMissingIndent,2719			_ => return None,2720		};2721		Some(res)2722	}2723}2724impl Text {2725	pub fn kind(&self) -> TextKind {2726		self.kind2727	}2728}2729impl std::fmt::Display for Text {2730	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2731		std::fmt::Display::fmt(self.syntax(), f)2732	}2733}2734impl AstToken for Number {2735	fn can_cast(kind: SyntaxKind) -> bool {2736		NumberKind::can_cast(kind)2737	}2738	fn cast(syntax: SyntaxToken) -> Option<Self> {2739		let kind = NumberKind::cast(syntax.kind())?;2740		Some(Number { syntax, kind })2741	}2742	fn syntax(&self) -> &SyntaxToken {2743		&self.syntax2744	}2745}2746impl NumberKind {2747	fn can_cast(kind: SyntaxKind) -> bool {2748		match kind {2749			FLOAT2750			| ERROR_FLOAT_JUNK_AFTER_POINT2751			| ERROR_FLOAT_JUNK_AFTER_EXPONENT2752			| ERROR_FLOAT_JUNK_AFTER_EXPONENT_SIGN => true,2753			_ => false,2754		}2755	}2756	pub fn cast(kind: SyntaxKind) -> Option<Self> {2757		let res = match kind {2758			FLOAT => Self::Float,2759			ERROR_FLOAT_JUNK_AFTER_POINT => Self::ErrorFloatJunkAfterPoint,2760			ERROR_FLOAT_JUNK_AFTER_EXPONENT => Self::ErrorFloatJunkAfterExponent,2761			ERROR_FLOAT_JUNK_AFTER_EXPONENT_SIGN => Self::ErrorFloatJunkAfterExponentSign,2762			_ => return None,2763		};2764		Some(res)2765	}2766}2767impl Number {2768	pub fn kind(&self) -> NumberKind {2769		self.kind2770	}2771}2772impl std::fmt::Display for Number {2773	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2774		std::fmt::Display::fmt(self.syntax(), f)2775	}2776}2777impl AstToken for ImportKind {2778	fn can_cast(kind: SyntaxKind) -> bool {2779		ImportKindKind::can_cast(kind)2780	}2781	fn cast(syntax: SyntaxToken) -> Option<Self> {2782		let kind = ImportKindKind::cast(syntax.kind())?;2783		Some(ImportKind { syntax, kind })2784	}2785	fn syntax(&self) -> &SyntaxToken {2786		&self.syntax2787	}2788}2789impl ImportKindKind {2790	fn can_cast(kind: SyntaxKind) -> bool {2791		match kind {2792			IMPORTSTR_KW | IMPORTBIN_KW | IMPORT_KW => true,2793			_ => false,2794		}2795	}2796	pub fn cast(kind: SyntaxKind) -> Option<Self> {2797		let res = match kind {2798			IMPORTSTR_KW => Self::ImportstrKw,2799			IMPORTBIN_KW => Self::ImportbinKw,2800			IMPORT_KW => Self::ImportKw,2801			_ => return None,2802		};2803		Some(res)2804	}2805}2806impl ImportKind {2807	pub fn kind(&self) -> ImportKindKind {2808		self.kind2809	}2810}2811impl std::fmt::Display for ImportKind {2812	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2813		std::fmt::Display::fmt(self.syntax(), f)2814	}2815}2816impl AstToken for Visibility {2817	fn can_cast(kind: SyntaxKind) -> bool {2818		VisibilityKind::can_cast(kind)2819	}2820	fn cast(syntax: SyntaxToken) -> Option<Self> {2821		let kind = VisibilityKind::cast(syntax.kind())?;2822		Some(Visibility { syntax, kind })2823	}2824	fn syntax(&self) -> &SyntaxToken {2825		&self.syntax2826	}2827}2828impl VisibilityKind {2829	fn can_cast(kind: SyntaxKind) -> bool {2830		match kind {2831			COLONCOLONCOLON | COLONCOLON | COLON => true,2832			_ => false,2833		}2834	}2835	pub fn cast(kind: SyntaxKind) -> Option<Self> {2836		let res = match kind {2837			COLONCOLONCOLON => Self::Coloncoloncolon,2838			COLONCOLON => Self::Coloncolon,2839			COLON => Self::Colon,2840			_ => return None,2841		};2842		Some(res)2843	}2844}2845impl Visibility {2846	pub fn kind(&self) -> VisibilityKind {2847		self.kind2848	}2849}2850impl std::fmt::Display for Visibility {2851	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2852		std::fmt::Display::fmt(self.syntax(), f)2853	}2854}2855impl AstToken for Trivia {2856	fn can_cast(kind: SyntaxKind) -> bool {2857		TriviaKind::can_cast(kind)2858	}2859	fn cast(syntax: SyntaxToken) -> Option<Self> {2860		let kind = TriviaKind::cast(syntax.kind())?;2861		Some(Trivia { syntax, kind })2862	}2863	fn syntax(&self) -> &SyntaxToken {2864		&self.syntax2865	}2866}2867impl TriviaKind {2868	fn can_cast(kind: SyntaxKind) -> bool {2869		match kind {2870			WHITESPACE2871			| MULTI_LINE_COMMENT2872			| ERROR_COMMENT_TOO_SHORT2873			| ERROR_COMMENT_UNTERMINATED2874			| SINGLE_LINE_HASH_COMMENT2875			| SINGLE_LINE_SLASH_COMMENT => true,2876			_ => false,2877		}2878	}2879	pub fn cast(kind: SyntaxKind) -> Option<Self> {2880		let res = match kind {2881			WHITESPACE => Self::Whitespace,2882			MULTI_LINE_COMMENT => Self::MultiLineComment,2883			ERROR_COMMENT_TOO_SHORT => Self::ErrorCommentTooShort,2884			ERROR_COMMENT_UNTERMINATED => Self::ErrorCommentUnterminated,2885			SINGLE_LINE_HASH_COMMENT => Self::SingleLineHashComment,2886			SINGLE_LINE_SLASH_COMMENT => Self::SingleLineSlashComment,2887			_ => return None,2888		};2889		Some(res)2890	}2891}2892impl Trivia {2893	pub fn kind(&self) -> TriviaKind {2894		self.kind2895	}2896}2897impl std::fmt::Display for Trivia {2898	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2899		std::fmt::Display::fmt(self.syntax(), f)2900	}2901}2902impl AstToken for ParsingError {2903	fn can_cast(kind: SyntaxKind) -> bool {2904		ParsingErrorKind::can_cast(kind)2905	}2906	fn cast(syntax: SyntaxToken) -> Option<Self> {2907		let kind = ParsingErrorKind::cast(syntax.kind())?;2908		Some(ParsingError { syntax, kind })2909	}2910	fn syntax(&self) -> &SyntaxToken {2911		&self.syntax2912	}2913}2914impl ParsingErrorKind {2915	fn can_cast(kind: SyntaxKind) -> bool {2916		match kind {2917			ERROR_MISSING_TOKEN | ERROR_UNEXPECTED_TOKEN => true,2918			_ => false,2919		}2920	}2921	pub fn cast(kind: SyntaxKind) -> Option<Self> {2922		let res = match kind {2923			ERROR_MISSING_TOKEN => Self::ErrorMissingToken,2924			ERROR_UNEXPECTED_TOKEN => Self::ErrorUnexpectedToken,2925			_ => return None,2926		};2927		Some(res)2928	}2929}2930impl ParsingError {2931	pub fn kind(&self) -> ParsingErrorKind {2932		self.kind2933	}2934}2935impl std::fmt::Display for ParsingError {2936	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2937		std::fmt::Display::fmt(self.syntax(), f)2938	}2939}2940impl std::fmt::Display for Expr {2941	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2942		std::fmt::Display::fmt(self.syntax(), f)2943	}2944}2945impl std::fmt::Display for ObjBody {2946	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2947		std::fmt::Display::fmt(self.syntax(), f)2948	}2949}2950impl std::fmt::Display for CompSpec {2951	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2952		std::fmt::Display::fmt(self.syntax(), f)2953	}2954}2955impl std::fmt::Display for Bind {2956	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2957		std::fmt::Display::fmt(self.syntax(), f)2958	}2959}2960impl std::fmt::Display for Member {2961	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2962		std::fmt::Display::fmt(self.syntax(), f)2963	}2964}2965impl std::fmt::Display for Field {2966	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2967		std::fmt::Display::fmt(self.syntax(), f)2968	}2969}2970impl std::fmt::Display for FieldName {2971	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2972		std::fmt::Display::fmt(self.syntax(), f)2973	}2974}2975impl std::fmt::Display for Destruct {2976	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2977		std::fmt::Display::fmt(self.syntax(), f)2978	}2979}2980impl std::fmt::Display for DestructArrayPart {2981	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2982		std::fmt::Display::fmt(self.syntax(), f)2983	}2984}2985impl std::fmt::Display for SourceFile {2986	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2987		std::fmt::Display::fmt(self.syntax(), f)2988	}2989}2990impl std::fmt::Display for ExprBinary {2991	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2992		std::fmt::Display::fmt(self.syntax(), f)2993	}2994}2995impl std::fmt::Display for LhsExpr {2996	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2997		std::fmt::Display::fmt(self.syntax(), f)2998	}2999}3000impl std::fmt::Display for ExprUnary {3001	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3002		std::fmt::Display::fmt(self.syntax(), f)3003	}3004}3005impl std::fmt::Display for ExprSlice {3006	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3007		std::fmt::Display::fmt(self.syntax(), f)3008	}3009}3010impl std::fmt::Display for SliceDesc {3011	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3012		std::fmt::Display::fmt(self.syntax(), f)3013	}3014}3015impl std::fmt::Display for ExprIndex {3016	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3017		std::fmt::Display::fmt(self.syntax(), f)3018	}3019}3020impl std::fmt::Display for Name {3021	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3022		std::fmt::Display::fmt(self.syntax(), f)3023	}3024}3025impl std::fmt::Display for ExprIndexExpr {3026	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3027		std::fmt::Display::fmt(self.syntax(), f)3028	}3029}3030impl std::fmt::Display for ExprApply {3031	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3032		std::fmt::Display::fmt(self.syntax(), f)3033	}3034}3035impl std::fmt::Display for ArgsDesc {3036	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3037		std::fmt::Display::fmt(self.syntax(), f)3038	}3039}3040impl std::fmt::Display for ExprObjExtend {3041	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3042		std::fmt::Display::fmt(self.syntax(), f)3043	}3044}3045impl std::fmt::Display for ExprParened {3046	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3047		std::fmt::Display::fmt(self.syntax(), f)3048	}3049}3050impl std::fmt::Display for ExprLiteral {3051	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3052		std::fmt::Display::fmt(self.syntax(), f)3053	}3054}3055impl std::fmt::Display for ExprIntrinsicThisFile {3056	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3057		std::fmt::Display::fmt(self.syntax(), f)3058	}3059}3060impl std::fmt::Display for ExprIntrinsicId {3061	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3062		std::fmt::Display::fmt(self.syntax(), f)3063	}3064}3065impl std::fmt::Display for ExprIntrinsic {3066	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3067		std::fmt::Display::fmt(self.syntax(), f)3068	}3069}3070impl std::fmt::Display for ExprString {3071	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3072		std::fmt::Display::fmt(self.syntax(), f)3073	}3074}3075impl std::fmt::Display for ExprNumber {3076	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3077		std::fmt::Display::fmt(self.syntax(), f)3078	}3079}3080impl std::fmt::Display for ExprArray {3081	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3082		std::fmt::Display::fmt(self.syntax(), f)3083	}3084}3085impl std::fmt::Display for ExprObject {3086	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3087		std::fmt::Display::fmt(self.syntax(), f)3088	}3089}3090impl std::fmt::Display for ExprArrayComp {3091	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3092		std::fmt::Display::fmt(self.syntax(), f)3093	}3094}3095impl std::fmt::Display for ExprImport {3096	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3097		std::fmt::Display::fmt(self.syntax(), f)3098	}3099}3100impl std::fmt::Display for ExprVar {3101	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3102		std::fmt::Display::fmt(self.syntax(), f)3103	}3104}3105impl std::fmt::Display for ExprLocal {3106	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3107		std::fmt::Display::fmt(self.syntax(), f)3108	}3109}3110impl std::fmt::Display for ExprIfThenElse {3111	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3112		std::fmt::Display::fmt(self.syntax(), f)3113	}3114}3115impl std::fmt::Display for TrueExpr {3116	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3117		std::fmt::Display::fmt(self.syntax(), f)3118	}3119}3120impl std::fmt::Display for FalseExpr {3121	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3122		std::fmt::Display::fmt(self.syntax(), f)3123	}3124}3125impl std::fmt::Display for ExprFunction {3126	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3127		std::fmt::Display::fmt(self.syntax(), f)3128	}3129}3130impl std::fmt::Display for ParamsDesc {3131	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3132		std::fmt::Display::fmt(self.syntax(), f)3133	}3134}3135impl std::fmt::Display for ExprAssert {3136	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3137		std::fmt::Display::fmt(self.syntax(), f)3138	}3139}3140impl std::fmt::Display for Assertion {3141	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3142		std::fmt::Display::fmt(self.syntax(), f)3143	}3144}3145impl std::fmt::Display for ExprError {3146	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3147		std::fmt::Display::fmt(self.syntax(), f)3148	}3149}3150impl std::fmt::Display for SliceDescEnd {3151	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3152		std::fmt::Display::fmt(self.syntax(), f)3153	}3154}3155impl std::fmt::Display for SliceDescStep {3156	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3157		std::fmt::Display::fmt(self.syntax(), f)3158	}3159}3160impl std::fmt::Display for Arg {3161	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3162		std::fmt::Display::fmt(self.syntax(), f)3163	}3164}3165impl std::fmt::Display for ObjBodyComp {3166	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3167		std::fmt::Display::fmt(self.syntax(), f)3168	}3169}3170impl std::fmt::Display for ObjLocalPostComma {3171	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3172		std::fmt::Display::fmt(self.syntax(), f)3173	}3174}3175impl std::fmt::Display for ObjLocalPreComma {3176	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3177		std::fmt::Display::fmt(self.syntax(), f)3178	}3179}3180impl std::fmt::Display for ObjBodyMemberList {3181	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3182		std::fmt::Display::fmt(self.syntax(), f)3183	}3184}3185impl std::fmt::Display for ObjLocal {3186	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3187		std::fmt::Display::fmt(self.syntax(), f)3188	}3189}3190impl std::fmt::Display for MemberBindStmt {3191	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3192		std::fmt::Display::fmt(self.syntax(), f)3193	}3194}3195impl std::fmt::Display for MemberAssertStmt {3196	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3197		std::fmt::Display::fmt(self.syntax(), f)3198	}3199}3200impl std::fmt::Display for MemberField {3201	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3202		std::fmt::Display::fmt(self.syntax(), f)3203	}3204}3205impl std::fmt::Display for FieldNormal {3206	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3207		std::fmt::Display::fmt(self.syntax(), f)3208	}3209}3210impl std::fmt::Display for FieldMethod {3211	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3212		std::fmt::Display::fmt(self.syntax(), f)3213	}3214}3215impl std::fmt::Display for FieldNameFixed {3216	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3217		std::fmt::Display::fmt(self.syntax(), f)3218	}3219}3220impl std::fmt::Display for FieldNameDynamic {3221	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3222		std::fmt::Display::fmt(self.syntax(), f)3223	}3224}3225impl std::fmt::Display for ForSpec {3226	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3227		std::fmt::Display::fmt(self.syntax(), f)3228	}3229}3230impl std::fmt::Display for IfSpec {3231	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3232		std::fmt::Display::fmt(self.syntax(), f)3233	}3234}3235impl std::fmt::Display for BindDestruct {3236	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3237		std::fmt::Display::fmt(self.syntax(), f)3238	}3239}3240impl std::fmt::Display for BindFunction {3241	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3242		std::fmt::Display::fmt(self.syntax(), f)3243	}3244}3245impl std::fmt::Display for Param {3246	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3247		std::fmt::Display::fmt(self.syntax(), f)3248	}3249}3250impl std::fmt::Display for DestructFull {3251	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3252		std::fmt::Display::fmt(self.syntax(), f)3253	}3254}3255impl std::fmt::Display for DestructSkip {3256	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3257		std::fmt::Display::fmt(self.syntax(), f)3258	}3259}3260impl std::fmt::Display for DestructArray {3261	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3262		std::fmt::Display::fmt(self.syntax(), f)3263	}3264}3265impl std::fmt::Display for DestructObject {3266	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3267		std::fmt::Display::fmt(self.syntax(), f)3268	}3269}3270impl std::fmt::Display for DestructObjectField {3271	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3272		std::fmt::Display::fmt(self.syntax(), f)3273	}3274}3275impl std::fmt::Display for DestructRest {3276	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3277		std::fmt::Display::fmt(self.syntax(), f)3278	}3279}3280impl std::fmt::Display for DestructArrayElement {3281	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3282		std::fmt::Display::fmt(self.syntax(), f)3283	}3284}