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

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}1126impl AstNode for SourceFile {1127	fn can_cast(kind: SyntaxKind) -> bool {1128		kind == SOURCE_FILE1129	}1130	fn cast(syntax: SyntaxNode) -> Option<Self> {1131		if Self::can_cast(syntax.kind()) {1132			Some(Self { syntax })1133		} else {1134			None1135		}1136	}1137	fn syntax(&self) -> &SyntaxNode {1138		&self.syntax1139	}1140}1141impl AstNode for ExprBinary {1142	fn can_cast(kind: SyntaxKind) -> bool {1143		kind == EXPR_BINARY1144	}1145	fn cast(syntax: SyntaxNode) -> Option<Self> {1146		if Self::can_cast(syntax.kind()) {1147			Some(Self { syntax })1148		} else {1149			None1150		}1151	}1152	fn syntax(&self) -> &SyntaxNode {1153		&self.syntax1154	}1155}1156impl AstNode for LhsExpr {1157	fn can_cast(kind: SyntaxKind) -> bool {1158		kind == LHS_EXPR1159	}1160	fn cast(syntax: SyntaxNode) -> Option<Self> {1161		if Self::can_cast(syntax.kind()) {1162			Some(Self { syntax })1163		} else {1164			None1165		}1166	}1167	fn syntax(&self) -> &SyntaxNode {1168		&self.syntax1169	}1170}1171impl AstNode for ExprUnary {1172	fn can_cast(kind: SyntaxKind) -> bool {1173		kind == EXPR_UNARY1174	}1175	fn cast(syntax: SyntaxNode) -> Option<Self> {1176		if Self::can_cast(syntax.kind()) {1177			Some(Self { syntax })1178		} else {1179			None1180		}1181	}1182	fn syntax(&self) -> &SyntaxNode {1183		&self.syntax1184	}1185}1186impl AstNode for ExprSlice {1187	fn can_cast(kind: SyntaxKind) -> bool {1188		kind == EXPR_SLICE1189	}1190	fn cast(syntax: SyntaxNode) -> Option<Self> {1191		if Self::can_cast(syntax.kind()) {1192			Some(Self { syntax })1193		} else {1194			None1195		}1196	}1197	fn syntax(&self) -> &SyntaxNode {1198		&self.syntax1199	}1200}1201impl AstNode for SliceDesc {1202	fn can_cast(kind: SyntaxKind) -> bool {1203		kind == SLICE_DESC1204	}1205	fn cast(syntax: SyntaxNode) -> Option<Self> {1206		if Self::can_cast(syntax.kind()) {1207			Some(Self { syntax })1208		} else {1209			None1210		}1211	}1212	fn syntax(&self) -> &SyntaxNode {1213		&self.syntax1214	}1215}1216impl AstNode for ExprIndex {1217	fn can_cast(kind: SyntaxKind) -> bool {1218		kind == EXPR_INDEX1219	}1220	fn cast(syntax: SyntaxNode) -> Option<Self> {1221		if Self::can_cast(syntax.kind()) {1222			Some(Self { syntax })1223		} else {1224			None1225		}1226	}1227	fn syntax(&self) -> &SyntaxNode {1228		&self.syntax1229	}1230}1231impl AstNode for Name {1232	fn can_cast(kind: SyntaxKind) -> bool {1233		kind == NAME1234	}1235	fn cast(syntax: SyntaxNode) -> Option<Self> {1236		if Self::can_cast(syntax.kind()) {1237			Some(Self { syntax })1238		} else {1239			None1240		}1241	}1242	fn syntax(&self) -> &SyntaxNode {1243		&self.syntax1244	}1245}1246impl AstNode for ExprIndexExpr {1247	fn can_cast(kind: SyntaxKind) -> bool {1248		kind == EXPR_INDEX_EXPR1249	}1250	fn cast(syntax: SyntaxNode) -> Option<Self> {1251		if Self::can_cast(syntax.kind()) {1252			Some(Self { syntax })1253		} else {1254			None1255		}1256	}1257	fn syntax(&self) -> &SyntaxNode {1258		&self.syntax1259	}1260}1261impl AstNode for ExprApply {1262	fn can_cast(kind: SyntaxKind) -> bool {1263		kind == EXPR_APPLY1264	}1265	fn cast(syntax: SyntaxNode) -> Option<Self> {1266		if Self::can_cast(syntax.kind()) {1267			Some(Self { syntax })1268		} else {1269			None1270		}1271	}1272	fn syntax(&self) -> &SyntaxNode {1273		&self.syntax1274	}1275}1276impl AstNode for ArgsDesc {1277	fn can_cast(kind: SyntaxKind) -> bool {1278		kind == ARGS_DESC1279	}1280	fn cast(syntax: SyntaxNode) -> Option<Self> {1281		if Self::can_cast(syntax.kind()) {1282			Some(Self { syntax })1283		} else {1284			None1285		}1286	}1287	fn syntax(&self) -> &SyntaxNode {1288		&self.syntax1289	}1290}1291impl AstNode for ExprObjExtend {1292	fn can_cast(kind: SyntaxKind) -> bool {1293		kind == EXPR_OBJ_EXTEND1294	}1295	fn cast(syntax: SyntaxNode) -> Option<Self> {1296		if Self::can_cast(syntax.kind()) {1297			Some(Self { syntax })1298		} else {1299			None1300		}1301	}1302	fn syntax(&self) -> &SyntaxNode {1303		&self.syntax1304	}1305}1306impl AstNode for ExprParened {1307	fn can_cast(kind: SyntaxKind) -> bool {1308		kind == EXPR_PARENED1309	}1310	fn cast(syntax: SyntaxNode) -> Option<Self> {1311		if Self::can_cast(syntax.kind()) {1312			Some(Self { syntax })1313		} else {1314			None1315		}1316	}1317	fn syntax(&self) -> &SyntaxNode {1318		&self.syntax1319	}1320}1321impl AstNode for ExprLiteral {1322	fn can_cast(kind: SyntaxKind) -> bool {1323		kind == EXPR_LITERAL1324	}1325	fn cast(syntax: SyntaxNode) -> Option<Self> {1326		if Self::can_cast(syntax.kind()) {1327			Some(Self { syntax })1328		} else {1329			None1330		}1331	}1332	fn syntax(&self) -> &SyntaxNode {1333		&self.syntax1334	}1335}1336impl AstNode for ExprIntrinsicThisFile {1337	fn can_cast(kind: SyntaxKind) -> bool {1338		kind == EXPR_INTRINSIC_THIS_FILE1339	}1340	fn cast(syntax: SyntaxNode) -> Option<Self> {1341		if Self::can_cast(syntax.kind()) {1342			Some(Self { syntax })1343		} else {1344			None1345		}1346	}1347	fn syntax(&self) -> &SyntaxNode {1348		&self.syntax1349	}1350}1351impl AstNode for ExprIntrinsicId {1352	fn can_cast(kind: SyntaxKind) -> bool {1353		kind == EXPR_INTRINSIC_ID1354	}1355	fn cast(syntax: SyntaxNode) -> Option<Self> {1356		if Self::can_cast(syntax.kind()) {1357			Some(Self { syntax })1358		} else {1359			None1360		}1361	}1362	fn syntax(&self) -> &SyntaxNode {1363		&self.syntax1364	}1365}1366impl AstNode for ExprIntrinsic {1367	fn can_cast(kind: SyntaxKind) -> bool {1368		kind == EXPR_INTRINSIC1369	}1370	fn cast(syntax: SyntaxNode) -> Option<Self> {1371		if Self::can_cast(syntax.kind()) {1372			Some(Self { syntax })1373		} else {1374			None1375		}1376	}1377	fn syntax(&self) -> &SyntaxNode {1378		&self.syntax1379	}1380}1381impl AstNode for ExprString {1382	fn can_cast(kind: SyntaxKind) -> bool {1383		kind == EXPR_STRING1384	}1385	fn cast(syntax: SyntaxNode) -> Option<Self> {1386		if Self::can_cast(syntax.kind()) {1387			Some(Self { syntax })1388		} else {1389			None1390		}1391	}1392	fn syntax(&self) -> &SyntaxNode {1393		&self.syntax1394	}1395}1396impl AstNode for ExprNumber {1397	fn can_cast(kind: SyntaxKind) -> bool {1398		kind == EXPR_NUMBER1399	}1400	fn cast(syntax: SyntaxNode) -> Option<Self> {1401		if Self::can_cast(syntax.kind()) {1402			Some(Self { syntax })1403		} else {1404			None1405		}1406	}1407	fn syntax(&self) -> &SyntaxNode {1408		&self.syntax1409	}1410}1411impl AstNode for ExprArray {1412	fn can_cast(kind: SyntaxKind) -> bool {1413		kind == EXPR_ARRAY1414	}1415	fn cast(syntax: SyntaxNode) -> Option<Self> {1416		if Self::can_cast(syntax.kind()) {1417			Some(Self { syntax })1418		} else {1419			None1420		}1421	}1422	fn syntax(&self) -> &SyntaxNode {1423		&self.syntax1424	}1425}1426impl AstNode for ExprObject {1427	fn can_cast(kind: SyntaxKind) -> bool {1428		kind == EXPR_OBJECT1429	}1430	fn cast(syntax: SyntaxNode) -> Option<Self> {1431		if Self::can_cast(syntax.kind()) {1432			Some(Self { syntax })1433		} else {1434			None1435		}1436	}1437	fn syntax(&self) -> &SyntaxNode {1438		&self.syntax1439	}1440}1441impl AstNode for ExprArrayComp {1442	fn can_cast(kind: SyntaxKind) -> bool {1443		kind == EXPR_ARRAY_COMP1444	}1445	fn cast(syntax: SyntaxNode) -> Option<Self> {1446		if Self::can_cast(syntax.kind()) {1447			Some(Self { syntax })1448		} else {1449			None1450		}1451	}1452	fn syntax(&self) -> &SyntaxNode {1453		&self.syntax1454	}1455}1456impl AstNode for ExprImport {1457	fn can_cast(kind: SyntaxKind) -> bool {1458		kind == EXPR_IMPORT1459	}1460	fn cast(syntax: SyntaxNode) -> Option<Self> {1461		if Self::can_cast(syntax.kind()) {1462			Some(Self { syntax })1463		} else {1464			None1465		}1466	}1467	fn syntax(&self) -> &SyntaxNode {1468		&self.syntax1469	}1470}1471impl AstNode for ExprVar {1472	fn can_cast(kind: SyntaxKind) -> bool {1473		kind == EXPR_VAR1474	}1475	fn cast(syntax: SyntaxNode) -> Option<Self> {1476		if Self::can_cast(syntax.kind()) {1477			Some(Self { syntax })1478		} else {1479			None1480		}1481	}1482	fn syntax(&self) -> &SyntaxNode {1483		&self.syntax1484	}1485}1486impl AstNode for ExprLocal {1487	fn can_cast(kind: SyntaxKind) -> bool {1488		kind == EXPR_LOCAL1489	}1490	fn cast(syntax: SyntaxNode) -> Option<Self> {1491		if Self::can_cast(syntax.kind()) {1492			Some(Self { syntax })1493		} else {1494			None1495		}1496	}1497	fn syntax(&self) -> &SyntaxNode {1498		&self.syntax1499	}1500}1501impl AstNode for ExprIfThenElse {1502	fn can_cast(kind: SyntaxKind) -> bool {1503		kind == EXPR_IF_THEN_ELSE1504	}1505	fn cast(syntax: SyntaxNode) -> Option<Self> {1506		if Self::can_cast(syntax.kind()) {1507			Some(Self { syntax })1508		} else {1509			None1510		}1511	}1512	fn syntax(&self) -> &SyntaxNode {1513		&self.syntax1514	}1515}1516impl AstNode for TrueExpr {1517	fn can_cast(kind: SyntaxKind) -> bool {1518		kind == TRUE_EXPR1519	}1520	fn cast(syntax: SyntaxNode) -> Option<Self> {1521		if Self::can_cast(syntax.kind()) {1522			Some(Self { syntax })1523		} else {1524			None1525		}1526	}1527	fn syntax(&self) -> &SyntaxNode {1528		&self.syntax1529	}1530}1531impl AstNode for FalseExpr {1532	fn can_cast(kind: SyntaxKind) -> bool {1533		kind == FALSE_EXPR1534	}1535	fn cast(syntax: SyntaxNode) -> Option<Self> {1536		if Self::can_cast(syntax.kind()) {1537			Some(Self { syntax })1538		} else {1539			None1540		}1541	}1542	fn syntax(&self) -> &SyntaxNode {1543		&self.syntax1544	}1545}1546impl AstNode for ExprFunction {1547	fn can_cast(kind: SyntaxKind) -> bool {1548		kind == EXPR_FUNCTION1549	}1550	fn cast(syntax: SyntaxNode) -> Option<Self> {1551		if Self::can_cast(syntax.kind()) {1552			Some(Self { syntax })1553		} else {1554			None1555		}1556	}1557	fn syntax(&self) -> &SyntaxNode {1558		&self.syntax1559	}1560}1561impl AstNode for ParamsDesc {1562	fn can_cast(kind: SyntaxKind) -> bool {1563		kind == PARAMS_DESC1564	}1565	fn cast(syntax: SyntaxNode) -> Option<Self> {1566		if Self::can_cast(syntax.kind()) {1567			Some(Self { syntax })1568		} else {1569			None1570		}1571	}1572	fn syntax(&self) -> &SyntaxNode {1573		&self.syntax1574	}1575}1576impl AstNode for ExprAssert {1577	fn can_cast(kind: SyntaxKind) -> bool {1578		kind == EXPR_ASSERT1579	}1580	fn cast(syntax: SyntaxNode) -> Option<Self> {1581		if Self::can_cast(syntax.kind()) {1582			Some(Self { syntax })1583		} else {1584			None1585		}1586	}1587	fn syntax(&self) -> &SyntaxNode {1588		&self.syntax1589	}1590}1591impl AstNode for Assertion {1592	fn can_cast(kind: SyntaxKind) -> bool {1593		kind == ASSERTION1594	}1595	fn cast(syntax: SyntaxNode) -> Option<Self> {1596		if Self::can_cast(syntax.kind()) {1597			Some(Self { syntax })1598		} else {1599			None1600		}1601	}1602	fn syntax(&self) -> &SyntaxNode {1603		&self.syntax1604	}1605}1606impl AstNode for ExprError {1607	fn can_cast(kind: SyntaxKind) -> bool {1608		kind == EXPR_ERROR1609	}1610	fn cast(syntax: SyntaxNode) -> Option<Self> {1611		if Self::can_cast(syntax.kind()) {1612			Some(Self { syntax })1613		} else {1614			None1615		}1616	}1617	fn syntax(&self) -> &SyntaxNode {1618		&self.syntax1619	}1620}1621impl AstNode for SliceDescEnd {1622	fn can_cast(kind: SyntaxKind) -> bool {1623		kind == SLICE_DESC_END1624	}1625	fn cast(syntax: SyntaxNode) -> Option<Self> {1626		if Self::can_cast(syntax.kind()) {1627			Some(Self { syntax })1628		} else {1629			None1630		}1631	}1632	fn syntax(&self) -> &SyntaxNode {1633		&self.syntax1634	}1635}1636impl AstNode for SliceDescStep {1637	fn can_cast(kind: SyntaxKind) -> bool {1638		kind == SLICE_DESC_STEP1639	}1640	fn cast(syntax: SyntaxNode) -> Option<Self> {1641		if Self::can_cast(syntax.kind()) {1642			Some(Self { syntax })1643		} else {1644			None1645		}1646	}1647	fn syntax(&self) -> &SyntaxNode {1648		&self.syntax1649	}1650}1651impl AstNode for Arg {1652	fn can_cast(kind: SyntaxKind) -> bool {1653		kind == ARG1654	}1655	fn cast(syntax: SyntaxNode) -> Option<Self> {1656		if Self::can_cast(syntax.kind()) {1657			Some(Self { syntax })1658		} else {1659			None1660		}1661	}1662	fn syntax(&self) -> &SyntaxNode {1663		&self.syntax1664	}1665}1666impl AstNode for ObjBodyComp {1667	fn can_cast(kind: SyntaxKind) -> bool {1668		kind == OBJ_BODY_COMP1669	}1670	fn cast(syntax: SyntaxNode) -> Option<Self> {1671		if Self::can_cast(syntax.kind()) {1672			Some(Self { syntax })1673		} else {1674			None1675		}1676	}1677	fn syntax(&self) -> &SyntaxNode {1678		&self.syntax1679	}1680}1681impl AstNode for ObjLocalPostComma {1682	fn can_cast(kind: SyntaxKind) -> bool {1683		kind == OBJ_LOCAL_POST_COMMA1684	}1685	fn cast(syntax: SyntaxNode) -> Option<Self> {1686		if Self::can_cast(syntax.kind()) {1687			Some(Self { syntax })1688		} else {1689			None1690		}1691	}1692	fn syntax(&self) -> &SyntaxNode {1693		&self.syntax1694	}1695}1696impl AstNode for ObjLocalPreComma {1697	fn can_cast(kind: SyntaxKind) -> bool {1698		kind == OBJ_LOCAL_PRE_COMMA1699	}1700	fn cast(syntax: SyntaxNode) -> Option<Self> {1701		if Self::can_cast(syntax.kind()) {1702			Some(Self { syntax })1703		} else {1704			None1705		}1706	}1707	fn syntax(&self) -> &SyntaxNode {1708		&self.syntax1709	}1710}1711impl AstNode for ObjBodyMemberList {1712	fn can_cast(kind: SyntaxKind) -> bool {1713		kind == OBJ_BODY_MEMBER_LIST1714	}1715	fn cast(syntax: SyntaxNode) -> Option<Self> {1716		if Self::can_cast(syntax.kind()) {1717			Some(Self { syntax })1718		} else {1719			None1720		}1721	}1722	fn syntax(&self) -> &SyntaxNode {1723		&self.syntax1724	}1725}1726impl AstNode for ObjLocal {1727	fn can_cast(kind: SyntaxKind) -> bool {1728		kind == OBJ_LOCAL1729	}1730	fn cast(syntax: SyntaxNode) -> Option<Self> {1731		if Self::can_cast(syntax.kind()) {1732			Some(Self { syntax })1733		} else {1734			None1735		}1736	}1737	fn syntax(&self) -> &SyntaxNode {1738		&self.syntax1739	}1740}1741impl AstNode for MemberBindStmt {1742	fn can_cast(kind: SyntaxKind) -> bool {1743		kind == MEMBER_BIND_STMT1744	}1745	fn cast(syntax: SyntaxNode) -> Option<Self> {1746		if Self::can_cast(syntax.kind()) {1747			Some(Self { syntax })1748		} else {1749			None1750		}1751	}1752	fn syntax(&self) -> &SyntaxNode {1753		&self.syntax1754	}1755}1756impl AstNode for MemberAssertStmt {1757	fn can_cast(kind: SyntaxKind) -> bool {1758		kind == MEMBER_ASSERT_STMT1759	}1760	fn cast(syntax: SyntaxNode) -> Option<Self> {1761		if Self::can_cast(syntax.kind()) {1762			Some(Self { syntax })1763		} else {1764			None1765		}1766	}1767	fn syntax(&self) -> &SyntaxNode {1768		&self.syntax1769	}1770}1771impl AstNode for MemberField {1772	fn can_cast(kind: SyntaxKind) -> bool {1773		kind == MEMBER_FIELD1774	}1775	fn cast(syntax: SyntaxNode) -> Option<Self> {1776		if Self::can_cast(syntax.kind()) {1777			Some(Self { syntax })1778		} else {1779			None1780		}1781	}1782	fn syntax(&self) -> &SyntaxNode {1783		&self.syntax1784	}1785}1786impl AstNode for FieldNormal {1787	fn can_cast(kind: SyntaxKind) -> bool {1788		kind == FIELD_NORMAL1789	}1790	fn cast(syntax: SyntaxNode) -> Option<Self> {1791		if Self::can_cast(syntax.kind()) {1792			Some(Self { syntax })1793		} else {1794			None1795		}1796	}1797	fn syntax(&self) -> &SyntaxNode {1798		&self.syntax1799	}1800}1801impl AstNode for FieldMethod {1802	fn can_cast(kind: SyntaxKind) -> bool {1803		kind == FIELD_METHOD1804	}1805	fn cast(syntax: SyntaxNode) -> Option<Self> {1806		if Self::can_cast(syntax.kind()) {1807			Some(Self { syntax })1808		} else {1809			None1810		}1811	}1812	fn syntax(&self) -> &SyntaxNode {1813		&self.syntax1814	}1815}1816impl AstNode for FieldNameFixed {1817	fn can_cast(kind: SyntaxKind) -> bool {1818		kind == FIELD_NAME_FIXED1819	}1820	fn cast(syntax: SyntaxNode) -> Option<Self> {1821		if Self::can_cast(syntax.kind()) {1822			Some(Self { syntax })1823		} else {1824			None1825		}1826	}1827	fn syntax(&self) -> &SyntaxNode {1828		&self.syntax1829	}1830}1831impl AstNode for FieldNameDynamic {1832	fn can_cast(kind: SyntaxKind) -> bool {1833		kind == FIELD_NAME_DYNAMIC1834	}1835	fn cast(syntax: SyntaxNode) -> Option<Self> {1836		if Self::can_cast(syntax.kind()) {1837			Some(Self { syntax })1838		} else {1839			None1840		}1841	}1842	fn syntax(&self) -> &SyntaxNode {1843		&self.syntax1844	}1845}1846impl AstNode for ForSpec {1847	fn can_cast(kind: SyntaxKind) -> bool {1848		kind == FOR_SPEC1849	}1850	fn cast(syntax: SyntaxNode) -> Option<Self> {1851		if Self::can_cast(syntax.kind()) {1852			Some(Self { syntax })1853		} else {1854			None1855		}1856	}1857	fn syntax(&self) -> &SyntaxNode {1858		&self.syntax1859	}1860}1861impl AstNode for IfSpec {1862	fn can_cast(kind: SyntaxKind) -> bool {1863		kind == IF_SPEC1864	}1865	fn cast(syntax: SyntaxNode) -> Option<Self> {1866		if Self::can_cast(syntax.kind()) {1867			Some(Self { syntax })1868		} else {1869			None1870		}1871	}1872	fn syntax(&self) -> &SyntaxNode {1873		&self.syntax1874	}1875}1876impl AstNode for BindDestruct {1877	fn can_cast(kind: SyntaxKind) -> bool {1878		kind == BIND_DESTRUCT1879	}1880	fn cast(syntax: SyntaxNode) -> Option<Self> {1881		if Self::can_cast(syntax.kind()) {1882			Some(Self { syntax })1883		} else {1884			None1885		}1886	}1887	fn syntax(&self) -> &SyntaxNode {1888		&self.syntax1889	}1890}1891impl AstNode for BindFunction {1892	fn can_cast(kind: SyntaxKind) -> bool {1893		kind == BIND_FUNCTION1894	}1895	fn cast(syntax: SyntaxNode) -> Option<Self> {1896		if Self::can_cast(syntax.kind()) {1897			Some(Self { syntax })1898		} else {1899			None1900		}1901	}1902	fn syntax(&self) -> &SyntaxNode {1903		&self.syntax1904	}1905}1906impl AstNode for Param {1907	fn can_cast(kind: SyntaxKind) -> bool {1908		kind == PARAM1909	}1910	fn cast(syntax: SyntaxNode) -> Option<Self> {1911		if Self::can_cast(syntax.kind()) {1912			Some(Self { syntax })1913		} else {1914			None1915		}1916	}1917	fn syntax(&self) -> &SyntaxNode {1918		&self.syntax1919	}1920}1921impl AstNode for DestructFull {1922	fn can_cast(kind: SyntaxKind) -> bool {1923		kind == DESTRUCT_FULL1924	}1925	fn cast(syntax: SyntaxNode) -> Option<Self> {1926		if Self::can_cast(syntax.kind()) {1927			Some(Self { syntax })1928		} else {1929			None1930		}1931	}1932	fn syntax(&self) -> &SyntaxNode {1933		&self.syntax1934	}1935}1936impl AstNode for DestructSkip {1937	fn can_cast(kind: SyntaxKind) -> bool {1938		kind == DESTRUCT_SKIP1939	}1940	fn cast(syntax: SyntaxNode) -> Option<Self> {1941		if Self::can_cast(syntax.kind()) {1942			Some(Self { syntax })1943		} else {1944			None1945		}1946	}1947	fn syntax(&self) -> &SyntaxNode {1948		&self.syntax1949	}1950}1951impl AstNode for DestructArray {1952	fn can_cast(kind: SyntaxKind) -> bool {1953		kind == DESTRUCT_ARRAY1954	}1955	fn cast(syntax: SyntaxNode) -> Option<Self> {1956		if Self::can_cast(syntax.kind()) {1957			Some(Self { syntax })1958		} else {1959			None1960		}1961	}1962	fn syntax(&self) -> &SyntaxNode {1963		&self.syntax1964	}1965}1966impl AstNode for DestructObject {1967	fn can_cast(kind: SyntaxKind) -> bool {1968		kind == DESTRUCT_OBJECT1969	}1970	fn cast(syntax: SyntaxNode) -> Option<Self> {1971		if Self::can_cast(syntax.kind()) {1972			Some(Self { syntax })1973		} else {1974			None1975		}1976	}1977	fn syntax(&self) -> &SyntaxNode {1978		&self.syntax1979	}1980}1981impl AstNode for DestructObjectField {1982	fn can_cast(kind: SyntaxKind) -> bool {1983		kind == DESTRUCT_OBJECT_FIELD1984	}1985	fn cast(syntax: SyntaxNode) -> Option<Self> {1986		if Self::can_cast(syntax.kind()) {1987			Some(Self { syntax })1988		} else {1989			None1990		}1991	}1992	fn syntax(&self) -> &SyntaxNode {1993		&self.syntax1994	}1995}1996impl AstNode for DestructRest {1997	fn can_cast(kind: SyntaxKind) -> bool {1998		kind == DESTRUCT_REST1999	}2000	fn cast(syntax: SyntaxNode) -> Option<Self> {2001		if Self::can_cast(syntax.kind()) {2002			Some(Self { syntax })2003		} else {2004			None2005		}2006	}2007	fn syntax(&self) -> &SyntaxNode {2008		&self.syntax2009	}2010}2011impl AstNode for DestructArrayElement {2012	fn can_cast(kind: SyntaxKind) -> bool {2013		kind == DESTRUCT_ARRAY_ELEMENT2014	}2015	fn cast(syntax: SyntaxNode) -> Option<Self> {2016		if Self::can_cast(syntax.kind()) {2017			Some(Self { syntax })2018		} else {2019			None2020		}2021	}2022	fn syntax(&self) -> &SyntaxNode {2023		&self.syntax2024	}2025}2026impl From<ExprBinary> for Expr {2027	fn from(node: ExprBinary) -> Expr {2028		Expr::ExprBinary(node)2029	}2030}2031impl From<ExprUnary> for Expr {2032	fn from(node: ExprUnary) -> Expr {2033		Expr::ExprUnary(node)2034	}2035}2036impl From<ExprSlice> for Expr {2037	fn from(node: ExprSlice) -> Expr {2038		Expr::ExprSlice(node)2039	}2040}2041impl From<ExprIndex> for Expr {2042	fn from(node: ExprIndex) -> Expr {2043		Expr::ExprIndex(node)2044	}2045}2046impl From<ExprIndexExpr> for Expr {2047	fn from(node: ExprIndexExpr) -> Expr {2048		Expr::ExprIndexExpr(node)2049	}2050}2051impl From<ExprApply> for Expr {2052	fn from(node: ExprApply) -> Expr {2053		Expr::ExprApply(node)2054	}2055}2056impl From<ExprObjExtend> for Expr {2057	fn from(node: ExprObjExtend) -> Expr {2058		Expr::ExprObjExtend(node)2059	}2060}2061impl From<ExprParened> for Expr {2062	fn from(node: ExprParened) -> Expr {2063		Expr::ExprParened(node)2064	}2065}2066impl From<ExprIntrinsicThisFile> for Expr {2067	fn from(node: ExprIntrinsicThisFile) -> Expr {2068		Expr::ExprIntrinsicThisFile(node)2069	}2070}2071impl From<ExprIntrinsicId> for Expr {2072	fn from(node: ExprIntrinsicId) -> Expr {2073		Expr::ExprIntrinsicId(node)2074	}2075}2076impl From<ExprIntrinsic> for Expr {2077	fn from(node: ExprIntrinsic) -> Expr {2078		Expr::ExprIntrinsic(node)2079	}2080}2081impl From<ExprString> for Expr {2082	fn from(node: ExprString) -> Expr {2083		Expr::ExprString(node)2084	}2085}2086impl From<ExprNumber> for Expr {2087	fn from(node: ExprNumber) -> Expr {2088		Expr::ExprNumber(node)2089	}2090}2091impl From<ExprLiteral> for Expr {2092	fn from(node: ExprLiteral) -> Expr {2093		Expr::ExprLiteral(node)2094	}2095}2096impl From<ExprArray> for Expr {2097	fn from(node: ExprArray) -> Expr {2098		Expr::ExprArray(node)2099	}2100}2101impl From<ExprObject> for Expr {2102	fn from(node: ExprObject) -> Expr {2103		Expr::ExprObject(node)2104	}2105}2106impl From<ExprArrayComp> for Expr {2107	fn from(node: ExprArrayComp) -> Expr {2108		Expr::ExprArrayComp(node)2109	}2110}2111impl From<ExprImport> for Expr {2112	fn from(node: ExprImport) -> Expr {2113		Expr::ExprImport(node)2114	}2115}2116impl From<ExprVar> for Expr {2117	fn from(node: ExprVar) -> Expr {2118		Expr::ExprVar(node)2119	}2120}2121impl From<ExprLocal> for Expr {2122	fn from(node: ExprLocal) -> Expr {2123		Expr::ExprLocal(node)2124	}2125}2126impl From<ExprIfThenElse> for Expr {2127	fn from(node: ExprIfThenElse) -> Expr {2128		Expr::ExprIfThenElse(node)2129	}2130}2131impl From<ExprFunction> for Expr {2132	fn from(node: ExprFunction) -> Expr {2133		Expr::ExprFunction(node)2134	}2135}2136impl From<ExprAssert> for Expr {2137	fn from(node: ExprAssert) -> Expr {2138		Expr::ExprAssert(node)2139	}2140}2141impl From<ExprError> for Expr {2142	fn from(node: ExprError) -> Expr {2143		Expr::ExprError(node)2144	}2145}2146impl AstNode for Expr {2147	fn can_cast(kind: SyntaxKind) -> bool {2148		match kind {2149			EXPR_BINARY2150			| EXPR_UNARY2151			| EXPR_SLICE2152			| EXPR_INDEX2153			| EXPR_INDEX_EXPR2154			| EXPR_APPLY2155			| EXPR_OBJ_EXTEND2156			| EXPR_PARENED2157			| EXPR_INTRINSIC_THIS_FILE2158			| EXPR_INTRINSIC_ID2159			| EXPR_INTRINSIC2160			| EXPR_STRING2161			| EXPR_NUMBER2162			| EXPR_LITERAL2163			| EXPR_ARRAY2164			| EXPR_OBJECT2165			| EXPR_ARRAY_COMP2166			| EXPR_IMPORT2167			| EXPR_VAR2168			| EXPR_LOCAL2169			| EXPR_IF_THEN_ELSE2170			| EXPR_FUNCTION2171			| EXPR_ASSERT2172			| EXPR_ERROR => true,2173			_ => false,2174		}2175	}2176	fn cast(syntax: SyntaxNode) -> Option<Self> {2177		let res = match syntax.kind() {2178			EXPR_BINARY => Expr::ExprBinary(ExprBinary { syntax }),2179			EXPR_UNARY => Expr::ExprUnary(ExprUnary { syntax }),2180			EXPR_SLICE => Expr::ExprSlice(ExprSlice { syntax }),2181			EXPR_INDEX => Expr::ExprIndex(ExprIndex { syntax }),2182			EXPR_INDEX_EXPR => Expr::ExprIndexExpr(ExprIndexExpr { syntax }),2183			EXPR_APPLY => Expr::ExprApply(ExprApply { syntax }),2184			EXPR_OBJ_EXTEND => Expr::ExprObjExtend(ExprObjExtend { syntax }),2185			EXPR_PARENED => Expr::ExprParened(ExprParened { syntax }),2186			EXPR_INTRINSIC_THIS_FILE => {2187				Expr::ExprIntrinsicThisFile(ExprIntrinsicThisFile { syntax })2188			}2189			EXPR_INTRINSIC_ID => Expr::ExprIntrinsicId(ExprIntrinsicId { syntax }),2190			EXPR_INTRINSIC => Expr::ExprIntrinsic(ExprIntrinsic { syntax }),2191			EXPR_STRING => Expr::ExprString(ExprString { syntax }),2192			EXPR_NUMBER => Expr::ExprNumber(ExprNumber { syntax }),2193			EXPR_LITERAL => Expr::ExprLiteral(ExprLiteral { syntax }),2194			EXPR_ARRAY => Expr::ExprArray(ExprArray { syntax }),2195			EXPR_OBJECT => Expr::ExprObject(ExprObject { syntax }),2196			EXPR_ARRAY_COMP => Expr::ExprArrayComp(ExprArrayComp { syntax }),2197			EXPR_IMPORT => Expr::ExprImport(ExprImport { syntax }),2198			EXPR_VAR => Expr::ExprVar(ExprVar { syntax }),2199			EXPR_LOCAL => Expr::ExprLocal(ExprLocal { syntax }),2200			EXPR_IF_THEN_ELSE => Expr::ExprIfThenElse(ExprIfThenElse { syntax }),2201			EXPR_FUNCTION => Expr::ExprFunction(ExprFunction { syntax }),2202			EXPR_ASSERT => Expr::ExprAssert(ExprAssert { syntax }),2203			EXPR_ERROR => Expr::ExprError(ExprError { syntax }),2204			_ => return None,2205		};2206		Some(res)2207	}2208	fn syntax(&self) -> &SyntaxNode {2209		match self {2210			Expr::ExprBinary(it) => &it.syntax,2211			Expr::ExprUnary(it) => &it.syntax,2212			Expr::ExprSlice(it) => &it.syntax,2213			Expr::ExprIndex(it) => &it.syntax,2214			Expr::ExprIndexExpr(it) => &it.syntax,2215			Expr::ExprApply(it) => &it.syntax,2216			Expr::ExprObjExtend(it) => &it.syntax,2217			Expr::ExprParened(it) => &it.syntax,2218			Expr::ExprIntrinsicThisFile(it) => &it.syntax,2219			Expr::ExprIntrinsicId(it) => &it.syntax,2220			Expr::ExprIntrinsic(it) => &it.syntax,2221			Expr::ExprString(it) => &it.syntax,2222			Expr::ExprNumber(it) => &it.syntax,2223			Expr::ExprLiteral(it) => &it.syntax,2224			Expr::ExprArray(it) => &it.syntax,2225			Expr::ExprObject(it) => &it.syntax,2226			Expr::ExprArrayComp(it) => &it.syntax,2227			Expr::ExprImport(it) => &it.syntax,2228			Expr::ExprVar(it) => &it.syntax,2229			Expr::ExprLocal(it) => &it.syntax,2230			Expr::ExprIfThenElse(it) => &it.syntax,2231			Expr::ExprFunction(it) => &it.syntax,2232			Expr::ExprAssert(it) => &it.syntax,2233			Expr::ExprError(it) => &it.syntax,2234		}2235	}2236}2237impl From<ObjBodyComp> for ObjBody {2238	fn from(node: ObjBodyComp) -> ObjBody {2239		ObjBody::ObjBodyComp(node)2240	}2241}2242impl From<ObjBodyMemberList> for ObjBody {2243	fn from(node: ObjBodyMemberList) -> ObjBody {2244		ObjBody::ObjBodyMemberList(node)2245	}2246}2247impl AstNode for ObjBody {2248	fn can_cast(kind: SyntaxKind) -> bool {2249		match kind {2250			OBJ_BODY_COMP | OBJ_BODY_MEMBER_LIST => true,2251			_ => false,2252		}2253	}2254	fn cast(syntax: SyntaxNode) -> Option<Self> {2255		let res = match syntax.kind() {2256			OBJ_BODY_COMP => ObjBody::ObjBodyComp(ObjBodyComp { syntax }),2257			OBJ_BODY_MEMBER_LIST => ObjBody::ObjBodyMemberList(ObjBodyMemberList { syntax }),2258			_ => return None,2259		};2260		Some(res)2261	}2262	fn syntax(&self) -> &SyntaxNode {2263		match self {2264			ObjBody::ObjBodyComp(it) => &it.syntax,2265			ObjBody::ObjBodyMemberList(it) => &it.syntax,2266		}2267	}2268}2269impl From<ForSpec> for CompSpec {2270	fn from(node: ForSpec) -> CompSpec {2271		CompSpec::ForSpec(node)2272	}2273}2274impl From<IfSpec> for CompSpec {2275	fn from(node: IfSpec) -> CompSpec {2276		CompSpec::IfSpec(node)2277	}2278}2279impl AstNode for CompSpec {2280	fn can_cast(kind: SyntaxKind) -> bool {2281		match kind {2282			FOR_SPEC | IF_SPEC => true,2283			_ => false,2284		}2285	}2286	fn cast(syntax: SyntaxNode) -> Option<Self> {2287		let res = match syntax.kind() {2288			FOR_SPEC => CompSpec::ForSpec(ForSpec { syntax }),2289			IF_SPEC => CompSpec::IfSpec(IfSpec { syntax }),2290			_ => return None,2291		};2292		Some(res)2293	}2294	fn syntax(&self) -> &SyntaxNode {2295		match self {2296			CompSpec::ForSpec(it) => &it.syntax,2297			CompSpec::IfSpec(it) => &it.syntax,2298		}2299	}2300}2301impl From<BindDestruct> for Bind {2302	fn from(node: BindDestruct) -> Bind {2303		Bind::BindDestruct(node)2304	}2305}2306impl From<BindFunction> for Bind {2307	fn from(node: BindFunction) -> Bind {2308		Bind::BindFunction(node)2309	}2310}2311impl AstNode for Bind {2312	fn can_cast(kind: SyntaxKind) -> bool {2313		match kind {2314			BIND_DESTRUCT | BIND_FUNCTION => true,2315			_ => false,2316		}2317	}2318	fn cast(syntax: SyntaxNode) -> Option<Self> {2319		let res = match syntax.kind() {2320			BIND_DESTRUCT => Bind::BindDestruct(BindDestruct { syntax }),2321			BIND_FUNCTION => Bind::BindFunction(BindFunction { syntax }),2322			_ => return None,2323		};2324		Some(res)2325	}2326	fn syntax(&self) -> &SyntaxNode {2327		match self {2328			Bind::BindDestruct(it) => &it.syntax,2329			Bind::BindFunction(it) => &it.syntax,2330		}2331	}2332}2333impl From<MemberBindStmt> for Member {2334	fn from(node: MemberBindStmt) -> Member {2335		Member::MemberBindStmt(node)2336	}2337}2338impl From<MemberAssertStmt> for Member {2339	fn from(node: MemberAssertStmt) -> Member {2340		Member::MemberAssertStmt(node)2341	}2342}2343impl From<MemberField> for Member {2344	fn from(node: MemberField) -> Member {2345		Member::MemberField(node)2346	}2347}2348impl AstNode for Member {2349	fn can_cast(kind: SyntaxKind) -> bool {2350		match kind {2351			MEMBER_BIND_STMT | MEMBER_ASSERT_STMT | MEMBER_FIELD => true,2352			_ => false,2353		}2354	}2355	fn cast(syntax: SyntaxNode) -> Option<Self> {2356		let res = match syntax.kind() {2357			MEMBER_BIND_STMT => Member::MemberBindStmt(MemberBindStmt { syntax }),2358			MEMBER_ASSERT_STMT => Member::MemberAssertStmt(MemberAssertStmt { syntax }),2359			MEMBER_FIELD => Member::MemberField(MemberField { syntax }),2360			_ => return None,2361		};2362		Some(res)2363	}2364	fn syntax(&self) -> &SyntaxNode {2365		match self {2366			Member::MemberBindStmt(it) => &it.syntax,2367			Member::MemberAssertStmt(it) => &it.syntax,2368			Member::MemberField(it) => &it.syntax,2369		}2370	}2371}2372impl From<FieldNormal> for Field {2373	fn from(node: FieldNormal) -> Field {2374		Field::FieldNormal(node)2375	}2376}2377impl From<FieldMethod> for Field {2378	fn from(node: FieldMethod) -> Field {2379		Field::FieldMethod(node)2380	}2381}2382impl AstNode for Field {2383	fn can_cast(kind: SyntaxKind) -> bool {2384		match kind {2385			FIELD_NORMAL | FIELD_METHOD => true,2386			_ => false,2387		}2388	}2389	fn cast(syntax: SyntaxNode) -> Option<Self> {2390		let res = match syntax.kind() {2391			FIELD_NORMAL => Field::FieldNormal(FieldNormal { syntax }),2392			FIELD_METHOD => Field::FieldMethod(FieldMethod { syntax }),2393			_ => return None,2394		};2395		Some(res)2396	}2397	fn syntax(&self) -> &SyntaxNode {2398		match self {2399			Field::FieldNormal(it) => &it.syntax,2400			Field::FieldMethod(it) => &it.syntax,2401		}2402	}2403}2404impl From<FieldNameFixed> for FieldName {2405	fn from(node: FieldNameFixed) -> FieldName {2406		FieldName::FieldNameFixed(node)2407	}2408}2409impl From<FieldNameDynamic> for FieldName {2410	fn from(node: FieldNameDynamic) -> FieldName {2411		FieldName::FieldNameDynamic(node)2412	}2413}2414impl AstNode for FieldName {2415	fn can_cast(kind: SyntaxKind) -> bool {2416		match kind {2417			FIELD_NAME_FIXED | FIELD_NAME_DYNAMIC => true,2418			_ => false,2419		}2420	}2421	fn cast(syntax: SyntaxNode) -> Option<Self> {2422		let res = match syntax.kind() {2423			FIELD_NAME_FIXED => FieldName::FieldNameFixed(FieldNameFixed { syntax }),2424			FIELD_NAME_DYNAMIC => FieldName::FieldNameDynamic(FieldNameDynamic { syntax }),2425			_ => return None,2426		};2427		Some(res)2428	}2429	fn syntax(&self) -> &SyntaxNode {2430		match self {2431			FieldName::FieldNameFixed(it) => &it.syntax,2432			FieldName::FieldNameDynamic(it) => &it.syntax,2433		}2434	}2435}2436impl From<DestructFull> for Destruct {2437	fn from(node: DestructFull) -> Destruct {2438		Destruct::DestructFull(node)2439	}2440}2441impl From<DestructSkip> for Destruct {2442	fn from(node: DestructSkip) -> Destruct {2443		Destruct::DestructSkip(node)2444	}2445}2446impl From<DestructArray> for Destruct {2447	fn from(node: DestructArray) -> Destruct {2448		Destruct::DestructArray(node)2449	}2450}2451impl From<DestructObject> for Destruct {2452	fn from(node: DestructObject) -> Destruct {2453		Destruct::DestructObject(node)2454	}2455}2456impl AstNode for Destruct {2457	fn can_cast(kind: SyntaxKind) -> bool {2458		match kind {2459			DESTRUCT_FULL | DESTRUCT_SKIP | DESTRUCT_ARRAY | DESTRUCT_OBJECT => true,2460			_ => false,2461		}2462	}2463	fn cast(syntax: SyntaxNode) -> Option<Self> {2464		let res = match syntax.kind() {2465			DESTRUCT_FULL => Destruct::DestructFull(DestructFull { syntax }),2466			DESTRUCT_SKIP => Destruct::DestructSkip(DestructSkip { syntax }),2467			DESTRUCT_ARRAY => Destruct::DestructArray(DestructArray { syntax }),2468			DESTRUCT_OBJECT => Destruct::DestructObject(DestructObject { syntax }),2469			_ => return None,2470		};2471		Some(res)2472	}2473	fn syntax(&self) -> &SyntaxNode {2474		match self {2475			Destruct::DestructFull(it) => &it.syntax,2476			Destruct::DestructSkip(it) => &it.syntax,2477			Destruct::DestructArray(it) => &it.syntax,2478			Destruct::DestructObject(it) => &it.syntax,2479		}2480	}2481}2482impl From<DestructArrayElement> for DestructArrayPart {2483	fn from(node: DestructArrayElement) -> DestructArrayPart {2484		DestructArrayPart::DestructArrayElement(node)2485	}2486}2487impl From<DestructRest> for DestructArrayPart {2488	fn from(node: DestructRest) -> DestructArrayPart {2489		DestructArrayPart::DestructRest(node)2490	}2491}2492impl AstNode for DestructArrayPart {2493	fn can_cast(kind: SyntaxKind) -> bool {2494		match kind {2495			DESTRUCT_ARRAY_ELEMENT | DESTRUCT_REST => true,2496			_ => false,2497		}2498	}2499	fn cast(syntax: SyntaxNode) -> Option<Self> {2500		let res = match syntax.kind() {2501			DESTRUCT_ARRAY_ELEMENT => {2502				DestructArrayPart::DestructArrayElement(DestructArrayElement { syntax })2503			}2504			DESTRUCT_REST => DestructArrayPart::DestructRest(DestructRest { syntax }),2505			_ => return None,2506		};2507		Some(res)2508	}2509	fn syntax(&self) -> &SyntaxNode {2510		match self {2511			DestructArrayPart::DestructArrayElement(it) => &it.syntax,2512			DestructArrayPart::DestructRest(it) => &it.syntax,2513		}2514	}2515}2516impl AstToken for BinaryOperator {2517	fn can_cast(kind: SyntaxKind) -> bool {2518		BinaryOperatorKind::can_cast(kind)2519	}2520	fn cast(syntax: SyntaxToken) -> Option<Self> {2521		let kind = BinaryOperatorKind::cast(syntax.kind())?;2522		Some(BinaryOperator { syntax, kind })2523	}2524	fn syntax(&self) -> &SyntaxToken {2525		&self.syntax2526	}2527}2528impl BinaryOperatorKind {2529	fn can_cast(kind: SyntaxKind) -> bool {2530		match kind {2531			OR | AND | BIT_OR | BIT_XOR | BIT_AND | EQ | NE | LT | GT | LE | GE | IN_KW | LHS2532			| RHS | PLUS | MINUS | MUL | DIV | MODULO | META_OBJECT_APPLY | ERROR_NO_OPERATOR => true,2533			_ => false,2534		}2535	}2536	pub fn cast(kind: SyntaxKind) -> Option<Self> {2537		let res = match kind {2538			OR => Self::Or,2539			AND => Self::And,2540			BIT_OR => Self::BitOr,2541			BIT_XOR => Self::BitXor,2542			BIT_AND => Self::BitAnd,2543			EQ => Self::Eq,2544			NE => Self::Ne,2545			LT => Self::Lt,2546			GT => Self::Gt,2547			LE => Self::Le,2548			GE => Self::Ge,2549			IN_KW => Self::InKw,2550			LHS => Self::Lhs,2551			RHS => Self::Rhs,2552			PLUS => Self::Plus,2553			MINUS => Self::Minus,2554			MUL => Self::Mul,2555			DIV => Self::Div,2556			MODULO => Self::Modulo,2557			META_OBJECT_APPLY => Self::MetaObjectApply,2558			ERROR_NO_OPERATOR => Self::ErrorNoOperator,2559			_ => return None,2560		};2561		Some(res)2562	}2563}2564impl BinaryOperator {2565	pub fn kind(&self) -> BinaryOperatorKind {2566		self.kind2567	}2568}2569impl std::fmt::Display for BinaryOperator {2570	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2571		std::fmt::Display::fmt(self.syntax(), f)2572	}2573}2574impl AstToken for UnaryOperator {2575	fn can_cast(kind: SyntaxKind) -> bool {2576		UnaryOperatorKind::can_cast(kind)2577	}2578	fn cast(syntax: SyntaxToken) -> Option<Self> {2579		let kind = UnaryOperatorKind::cast(syntax.kind())?;2580		Some(UnaryOperator { syntax, kind })2581	}2582	fn syntax(&self) -> &SyntaxToken {2583		&self.syntax2584	}2585}2586impl UnaryOperatorKind {2587	fn can_cast(kind: SyntaxKind) -> bool {2588		match kind {2589			MINUS | NOT | BIT_NOT => true,2590			_ => false,2591		}2592	}2593	pub fn cast(kind: SyntaxKind) -> Option<Self> {2594		let res = match kind {2595			MINUS => Self::Minus,2596			NOT => Self::Not,2597			BIT_NOT => Self::BitNot,2598			_ => return None,2599		};2600		Some(res)2601	}2602}2603impl UnaryOperator {2604	pub fn kind(&self) -> UnaryOperatorKind {2605		self.kind2606	}2607}2608impl std::fmt::Display for UnaryOperator {2609	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2610		std::fmt::Display::fmt(self.syntax(), f)2611	}2612}2613impl AstToken for Literal {2614	fn can_cast(kind: SyntaxKind) -> bool {2615		LiteralKind::can_cast(kind)2616	}2617	fn cast(syntax: SyntaxToken) -> Option<Self> {2618		let kind = LiteralKind::cast(syntax.kind())?;2619		Some(Literal { syntax, kind })2620	}2621	fn syntax(&self) -> &SyntaxToken {2622		&self.syntax2623	}2624}2625impl LiteralKind {2626	fn can_cast(kind: SyntaxKind) -> bool {2627		match kind {2628			NULL_KW | TRUE_KW | FALSE_KW | SELF_KW | DOLLAR | SUPER_KW => true,2629			_ => false,2630		}2631	}2632	pub fn cast(kind: SyntaxKind) -> Option<Self> {2633		let res = match kind {2634			NULL_KW => Self::NullKw,2635			TRUE_KW => Self::TrueKw,2636			FALSE_KW => Self::FalseKw,2637			SELF_KW => Self::SelfKw,2638			DOLLAR => Self::Dollar,2639			SUPER_KW => Self::SuperKw,2640			_ => return None,2641		};2642		Some(res)2643	}2644}2645impl Literal {2646	pub fn kind(&self) -> LiteralKind {2647		self.kind2648	}2649}2650impl std::fmt::Display for Literal {2651	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2652		std::fmt::Display::fmt(self.syntax(), f)2653	}2654}2655impl AstToken for Text {2656	fn can_cast(kind: SyntaxKind) -> bool {2657		TextKind::can_cast(kind)2658	}2659	fn cast(syntax: SyntaxToken) -> Option<Self> {2660		let kind = TextKind::cast(syntax.kind())?;2661		Some(Text { syntax, kind })2662	}2663	fn syntax(&self) -> &SyntaxToken {2664		&self.syntax2665	}2666}2667impl TextKind {2668	fn can_cast(kind: SyntaxKind) -> bool {2669		match kind {2670			STRING_DOUBLE2671			| ERROR_STRING_DOUBLE_UNTERMINATED2672			| STRING_SINGLE2673			| ERROR_STRING_SINGLE_UNTERMINATED2674			| STRING_DOUBLE_VERBATIM2675			| ERROR_STRING_DOUBLE_VERBATIM_UNTERMINATED2676			| STRING_SINGLE_VERBATIM2677			| ERROR_STRING_SINGLE_VERBATIM_UNTERMINATED2678			| ERROR_STRING_VERBATIM_MISSING_QUOTES2679			| STRING_BLOCK2680			| ERROR_STRING_BLOCK_UNEXPECTED_END2681			| ERROR_STRING_BLOCK_MISSING_NEW_LINE2682			| ERROR_STRING_BLOCK_MISSING_TERMINATION2683			| ERROR_STRING_BLOCK_MISSING_INDENT => true,2684			_ => false,2685		}2686	}2687	pub fn cast(kind: SyntaxKind) -> Option<Self> {2688		let res = match kind {2689			STRING_DOUBLE => Self::StringDouble,2690			ERROR_STRING_DOUBLE_UNTERMINATED => Self::ErrorStringDoubleUnterminated,2691			STRING_SINGLE => Self::StringSingle,2692			ERROR_STRING_SINGLE_UNTERMINATED => Self::ErrorStringSingleUnterminated,2693			STRING_DOUBLE_VERBATIM => Self::StringDoubleVerbatim,2694			ERROR_STRING_DOUBLE_VERBATIM_UNTERMINATED => {2695				Self::ErrorStringDoubleVerbatimUnterminated2696			}2697			STRING_SINGLE_VERBATIM => Self::StringSingleVerbatim,2698			ERROR_STRING_SINGLE_VERBATIM_UNTERMINATED => {2699				Self::ErrorStringSingleVerbatimUnterminated2700			}2701			ERROR_STRING_VERBATIM_MISSING_QUOTES => Self::ErrorStringVerbatimMissingQuotes,2702			STRING_BLOCK => Self::StringBlock,2703			ERROR_STRING_BLOCK_UNEXPECTED_END => Self::ErrorStringBlockUnexpectedEnd,2704			ERROR_STRING_BLOCK_MISSING_NEW_LINE => Self::ErrorStringBlockMissingNewLine,2705			ERROR_STRING_BLOCK_MISSING_TERMINATION => Self::ErrorStringBlockMissingTermination,2706			ERROR_STRING_BLOCK_MISSING_INDENT => Self::ErrorStringBlockMissingIndent,2707			_ => return None,2708		};2709		Some(res)2710	}2711}2712impl Text {2713	pub fn kind(&self) -> TextKind {2714		self.kind2715	}2716}2717impl std::fmt::Display for Text {2718	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2719		std::fmt::Display::fmt(self.syntax(), f)2720	}2721}2722impl AstToken for Number {2723	fn can_cast(kind: SyntaxKind) -> bool {2724		NumberKind::can_cast(kind)2725	}2726	fn cast(syntax: SyntaxToken) -> Option<Self> {2727		let kind = NumberKind::cast(syntax.kind())?;2728		Some(Number { syntax, kind })2729	}2730	fn syntax(&self) -> &SyntaxToken {2731		&self.syntax2732	}2733}2734impl NumberKind {2735	fn can_cast(kind: SyntaxKind) -> bool {2736		match kind {2737			FLOAT2738			| ERROR_FLOAT_JUNK_AFTER_POINT2739			| ERROR_FLOAT_JUNK_AFTER_EXPONENT2740			| ERROR_FLOAT_JUNK_AFTER_EXPONENT_SIGN => true,2741			_ => false,2742		}2743	}2744	pub fn cast(kind: SyntaxKind) -> Option<Self> {2745		let res = match kind {2746			FLOAT => Self::Float,2747			ERROR_FLOAT_JUNK_AFTER_POINT => Self::ErrorFloatJunkAfterPoint,2748			ERROR_FLOAT_JUNK_AFTER_EXPONENT => Self::ErrorFloatJunkAfterExponent,2749			ERROR_FLOAT_JUNK_AFTER_EXPONENT_SIGN => Self::ErrorFloatJunkAfterExponentSign,2750			_ => return None,2751		};2752		Some(res)2753	}2754}2755impl Number {2756	pub fn kind(&self) -> NumberKind {2757		self.kind2758	}2759}2760impl std::fmt::Display for Number {2761	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2762		std::fmt::Display::fmt(self.syntax(), f)2763	}2764}2765impl AstToken for ImportKind {2766	fn can_cast(kind: SyntaxKind) -> bool {2767		ImportKindKind::can_cast(kind)2768	}2769	fn cast(syntax: SyntaxToken) -> Option<Self> {2770		let kind = ImportKindKind::cast(syntax.kind())?;2771		Some(ImportKind { syntax, kind })2772	}2773	fn syntax(&self) -> &SyntaxToken {2774		&self.syntax2775	}2776}2777impl ImportKindKind {2778	fn can_cast(kind: SyntaxKind) -> bool {2779		match kind {2780			IMPORTSTR_KW | IMPORTBIN_KW | IMPORT_KW => true,2781			_ => false,2782		}2783	}2784	pub fn cast(kind: SyntaxKind) -> Option<Self> {2785		let res = match kind {2786			IMPORTSTR_KW => Self::ImportstrKw,2787			IMPORTBIN_KW => Self::ImportbinKw,2788			IMPORT_KW => Self::ImportKw,2789			_ => return None,2790		};2791		Some(res)2792	}2793}2794impl ImportKind {2795	pub fn kind(&self) -> ImportKindKind {2796		self.kind2797	}2798}2799impl std::fmt::Display for ImportKind {2800	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2801		std::fmt::Display::fmt(self.syntax(), f)2802	}2803}2804impl AstToken for Visibility {2805	fn can_cast(kind: SyntaxKind) -> bool {2806		VisibilityKind::can_cast(kind)2807	}2808	fn cast(syntax: SyntaxToken) -> Option<Self> {2809		let kind = VisibilityKind::cast(syntax.kind())?;2810		Some(Visibility { syntax, kind })2811	}2812	fn syntax(&self) -> &SyntaxToken {2813		&self.syntax2814	}2815}2816impl VisibilityKind {2817	fn can_cast(kind: SyntaxKind) -> bool {2818		match kind {2819			COLONCOLONCOLON | COLONCOLON | COLON => true,2820			_ => false,2821		}2822	}2823	pub fn cast(kind: SyntaxKind) -> Option<Self> {2824		let res = match kind {2825			COLONCOLONCOLON => Self::Coloncoloncolon,2826			COLONCOLON => Self::Coloncolon,2827			COLON => Self::Colon,2828			_ => return None,2829		};2830		Some(res)2831	}2832}2833impl Visibility {2834	pub fn kind(&self) -> VisibilityKind {2835		self.kind2836	}2837}2838impl std::fmt::Display for Visibility {2839	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2840		std::fmt::Display::fmt(self.syntax(), f)2841	}2842}2843impl AstToken for Trivia {2844	fn can_cast(kind: SyntaxKind) -> bool {2845		TriviaKind::can_cast(kind)2846	}2847	fn cast(syntax: SyntaxToken) -> Option<Self> {2848		let kind = TriviaKind::cast(syntax.kind())?;2849		Some(Trivia { syntax, kind })2850	}2851	fn syntax(&self) -> &SyntaxToken {2852		&self.syntax2853	}2854}2855impl TriviaKind {2856	fn can_cast(kind: SyntaxKind) -> bool {2857		match kind {2858			WHITESPACE2859			| MULTI_LINE_COMMENT2860			| ERROR_COMMENT_TOO_SHORT2861			| ERROR_COMMENT_UNTERMINATED2862			| SINGLE_LINE_HASH_COMMENT2863			| SINGLE_LINE_SLASH_COMMENT => true,2864			_ => false,2865		}2866	}2867	pub fn cast(kind: SyntaxKind) -> Option<Self> {2868		let res = match kind {2869			WHITESPACE => Self::Whitespace,2870			MULTI_LINE_COMMENT => Self::MultiLineComment,2871			ERROR_COMMENT_TOO_SHORT => Self::ErrorCommentTooShort,2872			ERROR_COMMENT_UNTERMINATED => Self::ErrorCommentUnterminated,2873			SINGLE_LINE_HASH_COMMENT => Self::SingleLineHashComment,2874			SINGLE_LINE_SLASH_COMMENT => Self::SingleLineSlashComment,2875			_ => return None,2876		};2877		Some(res)2878	}2879}2880impl Trivia {2881	pub fn kind(&self) -> TriviaKind {2882		self.kind2883	}2884}2885impl std::fmt::Display for Trivia {2886	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2887		std::fmt::Display::fmt(self.syntax(), f)2888	}2889}2890impl std::fmt::Display for Expr {2891	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2892		std::fmt::Display::fmt(self.syntax(), f)2893	}2894}2895impl std::fmt::Display for ObjBody {2896	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2897		std::fmt::Display::fmt(self.syntax(), f)2898	}2899}2900impl std::fmt::Display for CompSpec {2901	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2902		std::fmt::Display::fmt(self.syntax(), f)2903	}2904}2905impl std::fmt::Display for Bind {2906	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2907		std::fmt::Display::fmt(self.syntax(), f)2908	}2909}2910impl std::fmt::Display for Member {2911	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2912		std::fmt::Display::fmt(self.syntax(), f)2913	}2914}2915impl std::fmt::Display for Field {2916	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2917		std::fmt::Display::fmt(self.syntax(), f)2918	}2919}2920impl std::fmt::Display for FieldName {2921	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2922		std::fmt::Display::fmt(self.syntax(), f)2923	}2924}2925impl std::fmt::Display for Destruct {2926	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2927		std::fmt::Display::fmt(self.syntax(), f)2928	}2929}2930impl std::fmt::Display for DestructArrayPart {2931	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2932		std::fmt::Display::fmt(self.syntax(), f)2933	}2934}2935impl std::fmt::Display for SourceFile {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 ExprBinary {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 LhsExpr {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 ExprUnary {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 ExprSlice {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 SliceDesc {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 ExprIndex {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 Name {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 ExprIndexExpr {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 ExprApply {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 ArgsDesc {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 ExprObjExtend {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 ExprParened {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 ExprLiteral {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 ExprIntrinsicThisFile {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 ExprIntrinsicId {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 ExprIntrinsic {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 ExprString {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 ExprNumber {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 ExprArray {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 ExprObject {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 ExprArrayComp {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 ExprImport {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 ExprVar {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 ExprLocal {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 ExprIfThenElse {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 TrueExpr {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 FalseExpr {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 ExprFunction {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 ParamsDesc {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 ExprAssert {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 Assertion {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 ExprError {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 SliceDescEnd {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 SliceDescStep {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 Arg {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 ObjBodyComp {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 ObjLocalPostComma {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 ObjLocalPreComma {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 ObjBodyMemberList {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 ObjLocal {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 MemberBindStmt {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 MemberAssertStmt {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 MemberField {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 FieldNormal {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 FieldMethod {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 FieldNameFixed {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 FieldNameDynamic {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 ForSpec {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 IfSpec {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 BindDestruct {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 BindFunction {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 Param {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 DestructFull {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 DestructSkip {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 DestructArray {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 DestructObject {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 DestructObjectField {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 DestructRest {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 DestructArrayElement {3231	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3232		std::fmt::Display::fmt(self.syntax(), f)3233	}3234}