git.delta.rocks / jrsonnet / refs/commits / 5ad3c0601af8

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 string(&self) -> Option<String> {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 l_brace_token(&self) -> Option<SyntaxToken> {295		support::token(&self.syntax, T!['{'])296	}297	pub fn obj_body(&self) -> Option<ObjBody> {298		support::child(&self.syntax)299	}300	pub fn r_brace_token(&self) -> Option<SyntaxToken> {301		support::token(&self.syntax, T!['}'])302	}303}304305#[derive(Debug, Clone, PartialEq, Eq, Hash)]306pub struct ExprArrayComp {307	pub(crate) syntax: SyntaxNode,308}309impl ExprArrayComp {310	pub fn l_brack_token(&self) -> Option<SyntaxToken> {311		support::token(&self.syntax, T!['['])312	}313	pub fn expr(&self) -> Option<Expr> {314		support::child(&self.syntax)315	}316	pub fn comma_token(&self) -> Option<SyntaxToken> {317		support::token(&self.syntax, T![,])318	}319	pub fn comp_specs(&self) -> AstChildren<CompSpec> {320		support::children(&self.syntax)321	}322	pub fn r_brack_token(&self) -> Option<SyntaxToken> {323		support::token(&self.syntax, T![']'])324	}325}326327#[derive(Debug, Clone, PartialEq, Eq, Hash)]328pub struct ExprImport {329	pub(crate) syntax: SyntaxNode,330}331impl ExprImport {332	pub fn import_kind(&self) -> Option<ImportKind> {333		support::token_child(&self.syntax)334	}335	pub fn string(&self) -> Option<String> {336		support::token_child(&self.syntax)337	}338}339340#[derive(Debug, Clone, PartialEq, Eq, Hash)]341pub struct ExprVar {342	pub(crate) syntax: SyntaxNode,343}344impl ExprVar {345	pub fn name(&self) -> Option<Name> {346		support::child(&self.syntax)347	}348}349350#[derive(Debug, Clone, PartialEq, Eq, Hash)]351pub struct ExprLocal {352	pub(crate) syntax: SyntaxNode,353}354impl ExprLocal {355	pub fn local_kw_token(&self) -> Option<SyntaxToken> {356		support::token(&self.syntax, T![local])357	}358	pub fn binds(&self) -> AstChildren<Bind> {359		support::children(&self.syntax)360	}361	pub fn semi_token(&self) -> Option<SyntaxToken> {362		support::token(&self.syntax, T![;])363	}364	pub fn expr(&self) -> Option<Expr> {365		support::child(&self.syntax)366	}367}368369#[derive(Debug, Clone, PartialEq, Eq, Hash)]370pub struct ExprIfThenElse {371	pub(crate) syntax: SyntaxNode,372}373impl ExprIfThenElse {374	pub fn if_kw_token(&self) -> Option<SyntaxToken> {375		support::token(&self.syntax, T![if])376	}377	pub fn cond(&self) -> Option<Expr> {378		support::child(&self.syntax)379	}380	pub fn then_kw_token(&self) -> Option<SyntaxToken> {381		support::token(&self.syntax, T![then])382	}383	pub fn then(&self) -> Option<TrueExpr> {384		support::child(&self.syntax)385	}386	pub fn else_kw_token(&self) -> Option<SyntaxToken> {387		support::token(&self.syntax, T![else])388	}389	pub fn else_(&self) -> Option<FalseExpr> {390		support::child(&self.syntax)391	}392}393394#[derive(Debug, Clone, PartialEq, Eq, Hash)]395pub struct TrueExpr {396	pub(crate) syntax: SyntaxNode,397}398impl TrueExpr {399	pub fn expr(&self) -> Option<Expr> {400		support::child(&self.syntax)401	}402}403404#[derive(Debug, Clone, PartialEq, Eq, Hash)]405pub struct FalseExpr {406	pub(crate) syntax: SyntaxNode,407}408impl FalseExpr {409	pub fn expr(&self) -> Option<Expr> {410		support::child(&self.syntax)411	}412}413414#[derive(Debug, Clone, PartialEq, Eq, Hash)]415pub struct ExprFunction {416	pub(crate) syntax: SyntaxNode,417}418impl ExprFunction {419	pub fn function_kw_token(&self) -> Option<SyntaxToken> {420		support::token(&self.syntax, T![function])421	}422	pub fn l_paren_token(&self) -> Option<SyntaxToken> {423		support::token(&self.syntax, T!['('])424	}425	pub fn params_desc(&self) -> Option<ParamsDesc> {426		support::child(&self.syntax)427	}428	pub fn r_paren_token(&self) -> Option<SyntaxToken> {429		support::token(&self.syntax, T![')'])430	}431	pub fn expr(&self) -> Option<Expr> {432		support::child(&self.syntax)433	}434}435436#[derive(Debug, Clone, PartialEq, Eq, Hash)]437pub struct ParamsDesc {438	pub(crate) syntax: SyntaxNode,439}440impl ParamsDesc {441	pub fn l_paren_token(&self) -> Option<SyntaxToken> {442		support::token(&self.syntax, T!['('])443	}444	pub fn params(&self) -> AstChildren<Param> {445		support::children(&self.syntax)446	}447	pub fn r_paren_token(&self) -> Option<SyntaxToken> {448		support::token(&self.syntax, T![')'])449	}450}451452#[derive(Debug, Clone, PartialEq, Eq, Hash)]453pub struct ExprAssert {454	pub(crate) syntax: SyntaxNode,455}456impl ExprAssert {457	pub fn assertion(&self) -> Option<Assertion> {458		support::child(&self.syntax)459	}460	pub fn semi_token(&self) -> Option<SyntaxToken> {461		support::token(&self.syntax, T![;])462	}463	pub fn expr(&self) -> Option<Expr> {464		support::child(&self.syntax)465	}466}467468#[derive(Debug, Clone, PartialEq, Eq, Hash)]469pub struct Assertion {470	pub(crate) syntax: SyntaxNode,471}472impl Assertion {473	pub fn assert_kw_token(&self) -> Option<SyntaxToken> {474		support::token(&self.syntax, T![assert])475	}476	pub fn condition(&self) -> Option<LhsExpr> {477		support::child(&self.syntax)478	}479	pub fn colon_token(&self) -> Option<SyntaxToken> {480		support::token(&self.syntax, T![:])481	}482	pub fn message(&self) -> Option<Expr> {483		support::child(&self.syntax)484	}485}486487#[derive(Debug, Clone, PartialEq, Eq, Hash)]488pub struct ExprError {489	pub(crate) syntax: SyntaxNode,490}491impl ExprError {492	pub fn error_kw_token(&self) -> Option<SyntaxToken> {493		support::token(&self.syntax, T![error])494	}495	pub fn expr(&self) -> Option<Expr> {496		support::child(&self.syntax)497	}498}499500#[derive(Debug, Clone, PartialEq, Eq, Hash)]501pub struct SliceDescEnd {502	pub(crate) syntax: SyntaxNode,503}504impl SliceDescEnd {505	pub fn expr(&self) -> Option<Expr> {506		support::child(&self.syntax)507	}508}509510#[derive(Debug, Clone, PartialEq, Eq, Hash)]511pub struct SliceDescStep {512	pub(crate) syntax: SyntaxNode,513}514impl SliceDescStep {515	pub fn expr(&self) -> Option<Expr> {516		support::child(&self.syntax)517	}518}519520#[derive(Debug, Clone, PartialEq, Eq, Hash)]521pub struct Arg {522	pub(crate) syntax: SyntaxNode,523}524impl Arg {525	pub fn name(&self) -> Option<Name> {526		support::child(&self.syntax)527	}528	pub fn assign_token(&self) -> Option<SyntaxToken> {529		support::token(&self.syntax, T![=])530	}531	pub fn expr(&self) -> Option<Expr> {532		support::child(&self.syntax)533	}534}535536#[derive(Debug, Clone, PartialEq, Eq, Hash)]537pub struct ObjBodyComp {538	pub(crate) syntax: SyntaxNode,539}540impl ObjBodyComp {541	pub fn pre(&self) -> AstChildren<ObjLocalPostComma> {542		support::children(&self.syntax)543	}544	pub fn l_brack_token(&self) -> Option<SyntaxToken> {545		support::token(&self.syntax, T!['['])546	}547	pub fn key(&self) -> Option<LhsExpr> {548		support::child(&self.syntax)549	}550	pub fn r_brack_token(&self) -> Option<SyntaxToken> {551		support::token(&self.syntax, T![']'])552	}553	pub fn plus_token(&self) -> Option<SyntaxToken> {554		support::token(&self.syntax, T![+])555	}556	pub fn colon_token(&self) -> Option<SyntaxToken> {557		support::token(&self.syntax, T![:])558	}559	pub fn value(&self) -> Option<Expr> {560		support::child(&self.syntax)561	}562	pub fn post(&self) -> AstChildren<ObjLocalPreComma> {563		support::children(&self.syntax)564	}565	pub fn comp_specs(&self) -> AstChildren<CompSpec> {566		support::children(&self.syntax)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 members(&self) -> AstChildren<Member> {602		support::children(&self.syntax)603	}604}605606#[derive(Debug, Clone, PartialEq, Eq, Hash)]607pub struct ObjLocal {608	pub(crate) syntax: SyntaxNode,609}610impl ObjLocal {611	pub fn local_kw_token(&self) -> Option<SyntaxToken> {612		support::token(&self.syntax, T![local])613	}614	pub fn bind(&self) -> Option<Bind> {615		support::child(&self.syntax)616	}617}618619#[derive(Debug, Clone, PartialEq, Eq, Hash)]620pub struct MemberBindStmt {621	pub(crate) syntax: SyntaxNode,622}623impl MemberBindStmt {624	pub fn obj_local(&self) -> Option<ObjLocal> {625		support::child(&self.syntax)626	}627}628629#[derive(Debug, Clone, PartialEq, Eq, Hash)]630pub struct MemberAssertStmt {631	pub(crate) syntax: SyntaxNode,632}633impl MemberAssertStmt {634	pub fn assertion(&self) -> Option<Assertion> {635		support::child(&self.syntax)636	}637}638639#[derive(Debug, Clone, PartialEq, Eq, Hash)]640pub struct MemberField {641	pub(crate) syntax: SyntaxNode,642}643impl MemberField {644	pub fn field(&self) -> Option<Field> {645		support::child(&self.syntax)646	}647}648649#[derive(Debug, Clone, PartialEq, Eq, Hash)]650pub struct FieldNormal {651	pub(crate) syntax: SyntaxNode,652}653impl FieldNormal {654	pub fn field_name(&self) -> Option<FieldName> {655		support::child(&self.syntax)656	}657	pub fn plus_token(&self) -> Option<SyntaxToken> {658		support::token(&self.syntax, T![+])659	}660	pub fn visibility(&self) -> Option<Visibility> {661		support::token_child(&self.syntax)662	}663	pub fn expr(&self) -> Option<Expr> {664		support::child(&self.syntax)665	}666}667668#[derive(Debug, Clone, PartialEq, Eq, Hash)]669pub struct FieldMethod {670	pub(crate) syntax: SyntaxNode,671}672impl FieldMethod {673	pub fn field_name(&self) -> Option<FieldName> {674		support::child(&self.syntax)675	}676	pub fn params_desc(&self) -> Option<ParamsDesc> {677		support::child(&self.syntax)678	}679	pub fn visibility(&self) -> Option<Visibility> {680		support::token_child(&self.syntax)681	}682	pub fn expr(&self) -> Option<Expr> {683		support::child(&self.syntax)684	}685}686687#[derive(Debug, Clone, PartialEq, Eq, Hash)]688pub struct FieldNameFixed {689	pub(crate) syntax: SyntaxNode,690}691impl FieldNameFixed {692	pub fn id(&self) -> Option<Name> {693		support::child(&self.syntax)694	}695	pub fn string(&self) -> Option<String> {696		support::token_child(&self.syntax)697	}698}699700#[derive(Debug, Clone, PartialEq, Eq, Hash)]701pub struct FieldNameDynamic {702	pub(crate) syntax: SyntaxNode,703}704impl FieldNameDynamic {705	pub fn l_brack_token(&self) -> Option<SyntaxToken> {706		support::token(&self.syntax, T!['['])707	}708	pub fn expr(&self) -> Option<Expr> {709		support::child(&self.syntax)710	}711	pub fn r_brack_token(&self) -> Option<SyntaxToken> {712		support::token(&self.syntax, T![']'])713	}714}715716#[derive(Debug, Clone, PartialEq, Eq, Hash)]717pub struct ForSpec {718	pub(crate) syntax: SyntaxNode,719}720impl ForSpec {721	pub fn for_kw_token(&self) -> Option<SyntaxToken> {722		support::token(&self.syntax, T![for])723	}724	pub fn bind(&self) -> Option<Name> {725		support::child(&self.syntax)726	}727	pub fn in_kw_token(&self) -> Option<SyntaxToken> {728		support::token(&self.syntax, T![in])729	}730	pub fn expr(&self) -> Option<Expr> {731		support::child(&self.syntax)732	}733}734735#[derive(Debug, Clone, PartialEq, Eq, Hash)]736pub struct IfSpec {737	pub(crate) syntax: SyntaxNode,738}739impl IfSpec {740	pub fn if_kw_token(&self) -> Option<SyntaxToken> {741		support::token(&self.syntax, T![if])742	}743	pub fn expr(&self) -> Option<Expr> {744		support::child(&self.syntax)745	}746}747748#[derive(Debug, Clone, PartialEq, Eq, Hash)]749pub struct BindDestruct {750	pub(crate) syntax: SyntaxNode,751}752impl BindDestruct {753	pub fn into(&self) -> Option<Destruct> {754		support::child(&self.syntax)755	}756	pub fn assign_token(&self) -> Option<SyntaxToken> {757		support::token(&self.syntax, T![=])758	}759	pub fn value(&self) -> Option<Expr> {760		support::child(&self.syntax)761	}762}763764#[derive(Debug, Clone, PartialEq, Eq, Hash)]765pub struct BindFunction {766	pub(crate) syntax: SyntaxNode,767}768impl BindFunction {769	pub fn name(&self) -> Option<Name> {770		support::child(&self.syntax)771	}772	pub fn params(&self) -> Option<ParamsDesc> {773		support::child(&self.syntax)774	}775	pub fn assign_token(&self) -> Option<SyntaxToken> {776		support::token(&self.syntax, T![=])777	}778	pub fn value(&self) -> Option<Expr> {779		support::child(&self.syntax)780	}781}782783#[derive(Debug, Clone, PartialEq, Eq, Hash)]784pub struct Param {785	pub(crate) syntax: SyntaxNode,786}787impl Param {788	pub fn destruct(&self) -> Option<Destruct> {789		support::child(&self.syntax)790	}791	pub fn assign_token(&self) -> Option<SyntaxToken> {792		support::token(&self.syntax, T![=])793	}794	pub fn expr(&self) -> Option<Expr> {795		support::child(&self.syntax)796	}797}798799#[derive(Debug, Clone, PartialEq, Eq, Hash)]800pub struct DestructFull {801	pub(crate) syntax: SyntaxNode,802}803impl DestructFull {804	pub fn name(&self) -> Option<Name> {805		support::child(&self.syntax)806	}807}808809#[derive(Debug, Clone, PartialEq, Eq, Hash)]810pub struct DestructSkip {811	pub(crate) syntax: SyntaxNode,812}813impl DestructSkip {814	pub fn question_mark_token(&self) -> Option<SyntaxToken> {815		support::token(&self.syntax, T![?])816	}817}818819#[derive(Debug, Clone, PartialEq, Eq, Hash)]820pub struct DestructArray {821	pub(crate) syntax: SyntaxNode,822}823impl DestructArray {824	pub fn l_brack_token(&self) -> Option<SyntaxToken> {825		support::token(&self.syntax, T!['['])826	}827	pub fn destruct_array_parts(&self) -> AstChildren<DestructArrayPart> {828		support::children(&self.syntax)829	}830	pub fn r_brack_token(&self) -> Option<SyntaxToken> {831		support::token(&self.syntax, T![']'])832	}833}834835#[derive(Debug, Clone, PartialEq, Eq, Hash)]836pub struct DestructObject {837	pub(crate) syntax: SyntaxNode,838}839impl DestructObject {840	pub fn l_brace_token(&self) -> Option<SyntaxToken> {841		support::token(&self.syntax, T!['{'])842	}843	pub fn destruct_object_fields(&self) -> AstChildren<DestructObjectField> {844		support::children(&self.syntax)845	}846	pub fn destruct_rest(&self) -> Option<DestructRest> {847		support::child(&self.syntax)848	}849	pub fn comma_token(&self) -> Option<SyntaxToken> {850		support::token(&self.syntax, T![,])851	}852	pub fn r_brace_token(&self) -> Option<SyntaxToken> {853		support::token(&self.syntax, T!['}'])854	}855}856857#[derive(Debug, Clone, PartialEq, Eq, Hash)]858pub struct DestructObjectField {859	pub(crate) syntax: SyntaxNode,860}861impl DestructObjectField {862	pub fn field(&self) -> Option<Name> {863		support::child(&self.syntax)864	}865	pub fn colon_token(&self) -> Option<SyntaxToken> {866		support::token(&self.syntax, T![:])867	}868	pub fn destruct(&self) -> Option<Destruct> {869		support::child(&self.syntax)870	}871	pub fn assign_token(&self) -> Option<SyntaxToken> {872		support::token(&self.syntax, T![=])873	}874	pub fn expr(&self) -> Option<Expr> {875		support::child(&self.syntax)876	}877}878879#[derive(Debug, Clone, PartialEq, Eq, Hash)]880pub struct DestructRest {881	pub(crate) syntax: SyntaxNode,882}883impl DestructRest {884	pub fn dotdotdot_token(&self) -> Option<SyntaxToken> {885		support::token(&self.syntax, T![...])886	}887	pub fn into(&self) -> Option<Name> {888		support::child(&self.syntax)889	}890}891892#[derive(Debug, Clone, PartialEq, Eq, Hash)]893pub struct DestructArrayElement {894	pub(crate) syntax: SyntaxNode,895}896impl DestructArrayElement {897	pub fn destruct(&self) -> Option<Destruct> {898		support::child(&self.syntax)899	}900}901902#[derive(Debug, Clone, PartialEq, Eq, Hash)]903pub enum Expr {904	ExprBinary(ExprBinary),905	ExprUnary(ExprUnary),906	ExprSlice(ExprSlice),907	ExprIndex(ExprIndex),908	ExprIndexExpr(ExprIndexExpr),909	ExprApply(ExprApply),910	ExprObjExtend(ExprObjExtend),911	ExprParened(ExprParened),912	ExprIntrinsicThisFile(ExprIntrinsicThisFile),913	ExprIntrinsicId(ExprIntrinsicId),914	ExprIntrinsic(ExprIntrinsic),915	ExprString(ExprString),916	ExprNumber(ExprNumber),917	ExprLiteral(ExprLiteral),918	ExprArray(ExprArray),919	ExprObject(ExprObject),920	ExprArrayComp(ExprArrayComp),921	ExprImport(ExprImport),922	ExprVar(ExprVar),923	ExprLocal(ExprLocal),924	ExprIfThenElse(ExprIfThenElse),925	ExprFunction(ExprFunction),926	ExprAssert(ExprAssert),927	ExprError(ExprError),928}929930#[derive(Debug, Clone, PartialEq, Eq, Hash)]931pub enum ObjBody {932	ObjBodyComp(ObjBodyComp),933	ObjBodyMemberList(ObjBodyMemberList),934}935936#[derive(Debug, Clone, PartialEq, Eq, Hash)]937pub enum CompSpec {938	ForSpec(ForSpec),939	IfSpec(IfSpec),940}941942#[derive(Debug, Clone, PartialEq, Eq, Hash)]943pub enum Bind {944	BindDestruct(BindDestruct),945	BindFunction(BindFunction),946}947948#[derive(Debug, Clone, PartialEq, Eq, Hash)]949pub enum Member {950	MemberBindStmt(MemberBindStmt),951	MemberAssertStmt(MemberAssertStmt),952	MemberField(MemberField),953}954955#[derive(Debug, Clone, PartialEq, Eq, Hash)]956pub enum Field {957	FieldNormal(FieldNormal),958	FieldMethod(FieldMethod),959}960961#[derive(Debug, Clone, PartialEq, Eq, Hash)]962pub enum FieldName {963	FieldNameFixed(FieldNameFixed),964	FieldNameDynamic(FieldNameDynamic),965}966967#[derive(Debug, Clone, PartialEq, Eq, Hash)]968pub enum Destruct {969	DestructFull(DestructFull),970	DestructSkip(DestructSkip),971	DestructArray(DestructArray),972	DestructObject(DestructObject),973}974975#[derive(Debug, Clone, PartialEq, Eq, Hash)]976pub enum DestructArrayPart {977	DestructArrayElement(DestructArrayElement),978	DestructRest(DestructRest),979}980981#[derive(Debug, Clone, PartialEq, Eq, Hash)]982pub struct BinaryOperator {983	syntax: SyntaxToken,984	kind: BinaryOperatorKind,985}986987#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]988pub enum BinaryOperatorKind {989	Or,990	And,991	BitOr,992	BitXor,993	BitAnd,994	Eq,995	Ne,996	Lt,997	Gt,998	Le,999	Ge,1000	InKw,1001	Lhs,1002	Rhs,1003	Plus,1004	Minus,1005	Mul,1006	Div,1007	Modulo,1008	ErrorNoOperator,1009}10101011#[derive(Debug, Clone, PartialEq, Eq, Hash)]1012pub struct UnaryOperator {1013	syntax: SyntaxToken,1014	kind: UnaryOperatorKind,1015}10161017#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]1018pub enum UnaryOperatorKind {1019	Minus,1020	Not,1021	BitNot,1022}10231024#[derive(Debug, Clone, PartialEq, Eq, Hash)]1025pub struct Literal {1026	syntax: SyntaxToken,1027	kind: LiteralKind,1028}10291030#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]1031pub enum LiteralKind {1032	NullKw,1033	TrueKw,1034	FalseKw,1035	SelfKw,1036	Dollar,1037	SuperKw,1038}10391040#[derive(Debug, Clone, PartialEq, Eq, Hash)]1041pub struct String {1042	syntax: SyntaxToken,1043	kind: StringKind,1044}10451046#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]1047pub enum StringKind {1048	StringDouble,1049	StringSingle,1050	StringDoubleVerbatim,1051	StringSingleVerbatim,1052	StringBlock,1053}10541055#[derive(Debug, Clone, PartialEq, Eq, Hash)]1056pub struct Number {1057	syntax: SyntaxToken,1058	kind: NumberKind,1059}10601061#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]1062pub enum NumberKind {1063	Float,1064	MetaForceEnum,1065}10661067#[derive(Debug, Clone, PartialEq, Eq, Hash)]1068pub struct ImportKind {1069	syntax: SyntaxToken,1070	kind: ImportKindKind,1071}10721073#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]1074pub enum ImportKindKind {1075	ImportstrKw,1076	ImportbinKw,1077	ImportKw,1078}10791080#[derive(Debug, Clone, PartialEq, Eq, Hash)]1081pub struct Visibility {1082	syntax: SyntaxToken,1083	kind: VisibilityKind,1084}10851086#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]1087pub enum VisibilityKind {1088	Coloncoloncolon,1089	Coloncolon,1090	Colon,1091}1092impl AstNode for SourceFile {1093	fn can_cast(kind: SyntaxKind) -> bool {1094		kind == SOURCE_FILE1095	}1096	fn cast(syntax: SyntaxNode) -> Option<Self> {1097		if Self::can_cast(syntax.kind()) {1098			Some(Self { syntax })1099		} else {1100			None1101		}1102	}1103	fn syntax(&self) -> &SyntaxNode {1104		&self.syntax1105	}1106}1107impl AstNode for ExprBinary {1108	fn can_cast(kind: SyntaxKind) -> bool {1109		kind == EXPR_BINARY1110	}1111	fn cast(syntax: SyntaxNode) -> Option<Self> {1112		if Self::can_cast(syntax.kind()) {1113			Some(Self { syntax })1114		} else {1115			None1116		}1117	}1118	fn syntax(&self) -> &SyntaxNode {1119		&self.syntax1120	}1121}1122impl AstNode for LhsExpr {1123	fn can_cast(kind: SyntaxKind) -> bool {1124		kind == LHS_EXPR1125	}1126	fn cast(syntax: SyntaxNode) -> Option<Self> {1127		if Self::can_cast(syntax.kind()) {1128			Some(Self { syntax })1129		} else {1130			None1131		}1132	}1133	fn syntax(&self) -> &SyntaxNode {1134		&self.syntax1135	}1136}1137impl AstNode for ExprUnary {1138	fn can_cast(kind: SyntaxKind) -> bool {1139		kind == EXPR_UNARY1140	}1141	fn cast(syntax: SyntaxNode) -> Option<Self> {1142		if Self::can_cast(syntax.kind()) {1143			Some(Self { syntax })1144		} else {1145			None1146		}1147	}1148	fn syntax(&self) -> &SyntaxNode {1149		&self.syntax1150	}1151}1152impl AstNode for ExprSlice {1153	fn can_cast(kind: SyntaxKind) -> bool {1154		kind == EXPR_SLICE1155	}1156	fn cast(syntax: SyntaxNode) -> Option<Self> {1157		if Self::can_cast(syntax.kind()) {1158			Some(Self { syntax })1159		} else {1160			None1161		}1162	}1163	fn syntax(&self) -> &SyntaxNode {1164		&self.syntax1165	}1166}1167impl AstNode for SliceDesc {1168	fn can_cast(kind: SyntaxKind) -> bool {1169		kind == SLICE_DESC1170	}1171	fn cast(syntax: SyntaxNode) -> Option<Self> {1172		if Self::can_cast(syntax.kind()) {1173			Some(Self { syntax })1174		} else {1175			None1176		}1177	}1178	fn syntax(&self) -> &SyntaxNode {1179		&self.syntax1180	}1181}1182impl AstNode for ExprIndex {1183	fn can_cast(kind: SyntaxKind) -> bool {1184		kind == EXPR_INDEX1185	}1186	fn cast(syntax: SyntaxNode) -> Option<Self> {1187		if Self::can_cast(syntax.kind()) {1188			Some(Self { syntax })1189		} else {1190			None1191		}1192	}1193	fn syntax(&self) -> &SyntaxNode {1194		&self.syntax1195	}1196}1197impl AstNode for Name {1198	fn can_cast(kind: SyntaxKind) -> bool {1199		kind == NAME1200	}1201	fn cast(syntax: SyntaxNode) -> Option<Self> {1202		if Self::can_cast(syntax.kind()) {1203			Some(Self { syntax })1204		} else {1205			None1206		}1207	}1208	fn syntax(&self) -> &SyntaxNode {1209		&self.syntax1210	}1211}1212impl AstNode for ExprIndexExpr {1213	fn can_cast(kind: SyntaxKind) -> bool {1214		kind == EXPR_INDEX_EXPR1215	}1216	fn cast(syntax: SyntaxNode) -> Option<Self> {1217		if Self::can_cast(syntax.kind()) {1218			Some(Self { syntax })1219		} else {1220			None1221		}1222	}1223	fn syntax(&self) -> &SyntaxNode {1224		&self.syntax1225	}1226}1227impl AstNode for ExprApply {1228	fn can_cast(kind: SyntaxKind) -> bool {1229		kind == EXPR_APPLY1230	}1231	fn cast(syntax: SyntaxNode) -> Option<Self> {1232		if Self::can_cast(syntax.kind()) {1233			Some(Self { syntax })1234		} else {1235			None1236		}1237	}1238	fn syntax(&self) -> &SyntaxNode {1239		&self.syntax1240	}1241}1242impl AstNode for ArgsDesc {1243	fn can_cast(kind: SyntaxKind) -> bool {1244		kind == ARGS_DESC1245	}1246	fn cast(syntax: SyntaxNode) -> Option<Self> {1247		if Self::can_cast(syntax.kind()) {1248			Some(Self { syntax })1249		} else {1250			None1251		}1252	}1253	fn syntax(&self) -> &SyntaxNode {1254		&self.syntax1255	}1256}1257impl AstNode for ExprObjExtend {1258	fn can_cast(kind: SyntaxKind) -> bool {1259		kind == EXPR_OBJ_EXTEND1260	}1261	fn cast(syntax: SyntaxNode) -> Option<Self> {1262		if Self::can_cast(syntax.kind()) {1263			Some(Self { syntax })1264		} else {1265			None1266		}1267	}1268	fn syntax(&self) -> &SyntaxNode {1269		&self.syntax1270	}1271}1272impl AstNode for ExprParened {1273	fn can_cast(kind: SyntaxKind) -> bool {1274		kind == EXPR_PARENED1275	}1276	fn cast(syntax: SyntaxNode) -> Option<Self> {1277		if Self::can_cast(syntax.kind()) {1278			Some(Self { syntax })1279		} else {1280			None1281		}1282	}1283	fn syntax(&self) -> &SyntaxNode {1284		&self.syntax1285	}1286}1287impl AstNode for ExprLiteral {1288	fn can_cast(kind: SyntaxKind) -> bool {1289		kind == EXPR_LITERAL1290	}1291	fn cast(syntax: SyntaxNode) -> Option<Self> {1292		if Self::can_cast(syntax.kind()) {1293			Some(Self { syntax })1294		} else {1295			None1296		}1297	}1298	fn syntax(&self) -> &SyntaxNode {1299		&self.syntax1300	}1301}1302impl AstNode for ExprIntrinsicThisFile {1303	fn can_cast(kind: SyntaxKind) -> bool {1304		kind == EXPR_INTRINSIC_THIS_FILE1305	}1306	fn cast(syntax: SyntaxNode) -> Option<Self> {1307		if Self::can_cast(syntax.kind()) {1308			Some(Self { syntax })1309		} else {1310			None1311		}1312	}1313	fn syntax(&self) -> &SyntaxNode {1314		&self.syntax1315	}1316}1317impl AstNode for ExprIntrinsicId {1318	fn can_cast(kind: SyntaxKind) -> bool {1319		kind == EXPR_INTRINSIC_ID1320	}1321	fn cast(syntax: SyntaxNode) -> Option<Self> {1322		if Self::can_cast(syntax.kind()) {1323			Some(Self { syntax })1324		} else {1325			None1326		}1327	}1328	fn syntax(&self) -> &SyntaxNode {1329		&self.syntax1330	}1331}1332impl AstNode for ExprIntrinsic {1333	fn can_cast(kind: SyntaxKind) -> bool {1334		kind == EXPR_INTRINSIC1335	}1336	fn cast(syntax: SyntaxNode) -> Option<Self> {1337		if Self::can_cast(syntax.kind()) {1338			Some(Self { syntax })1339		} else {1340			None1341		}1342	}1343	fn syntax(&self) -> &SyntaxNode {1344		&self.syntax1345	}1346}1347impl AstNode for ExprString {1348	fn can_cast(kind: SyntaxKind) -> bool {1349		kind == EXPR_STRING1350	}1351	fn cast(syntax: SyntaxNode) -> Option<Self> {1352		if Self::can_cast(syntax.kind()) {1353			Some(Self { syntax })1354		} else {1355			None1356		}1357	}1358	fn syntax(&self) -> &SyntaxNode {1359		&self.syntax1360	}1361}1362impl AstNode for ExprNumber {1363	fn can_cast(kind: SyntaxKind) -> bool {1364		kind == EXPR_NUMBER1365	}1366	fn cast(syntax: SyntaxNode) -> Option<Self> {1367		if Self::can_cast(syntax.kind()) {1368			Some(Self { syntax })1369		} else {1370			None1371		}1372	}1373	fn syntax(&self) -> &SyntaxNode {1374		&self.syntax1375	}1376}1377impl AstNode for ExprArray {1378	fn can_cast(kind: SyntaxKind) -> bool {1379		kind == EXPR_ARRAY1380	}1381	fn cast(syntax: SyntaxNode) -> Option<Self> {1382		if Self::can_cast(syntax.kind()) {1383			Some(Self { syntax })1384		} else {1385			None1386		}1387	}1388	fn syntax(&self) -> &SyntaxNode {1389		&self.syntax1390	}1391}1392impl AstNode for ExprObject {1393	fn can_cast(kind: SyntaxKind) -> bool {1394		kind == EXPR_OBJECT1395	}1396	fn cast(syntax: SyntaxNode) -> Option<Self> {1397		if Self::can_cast(syntax.kind()) {1398			Some(Self { syntax })1399		} else {1400			None1401		}1402	}1403	fn syntax(&self) -> &SyntaxNode {1404		&self.syntax1405	}1406}1407impl AstNode for ExprArrayComp {1408	fn can_cast(kind: SyntaxKind) -> bool {1409		kind == EXPR_ARRAY_COMP1410	}1411	fn cast(syntax: SyntaxNode) -> Option<Self> {1412		if Self::can_cast(syntax.kind()) {1413			Some(Self { syntax })1414		} else {1415			None1416		}1417	}1418	fn syntax(&self) -> &SyntaxNode {1419		&self.syntax1420	}1421}1422impl AstNode for ExprImport {1423	fn can_cast(kind: SyntaxKind) -> bool {1424		kind == EXPR_IMPORT1425	}1426	fn cast(syntax: SyntaxNode) -> Option<Self> {1427		if Self::can_cast(syntax.kind()) {1428			Some(Self { syntax })1429		} else {1430			None1431		}1432	}1433	fn syntax(&self) -> &SyntaxNode {1434		&self.syntax1435	}1436}1437impl AstNode for ExprVar {1438	fn can_cast(kind: SyntaxKind) -> bool {1439		kind == EXPR_VAR1440	}1441	fn cast(syntax: SyntaxNode) -> Option<Self> {1442		if Self::can_cast(syntax.kind()) {1443			Some(Self { syntax })1444		} else {1445			None1446		}1447	}1448	fn syntax(&self) -> &SyntaxNode {1449		&self.syntax1450	}1451}1452impl AstNode for ExprLocal {1453	fn can_cast(kind: SyntaxKind) -> bool {1454		kind == EXPR_LOCAL1455	}1456	fn cast(syntax: SyntaxNode) -> Option<Self> {1457		if Self::can_cast(syntax.kind()) {1458			Some(Self { syntax })1459		} else {1460			None1461		}1462	}1463	fn syntax(&self) -> &SyntaxNode {1464		&self.syntax1465	}1466}1467impl AstNode for ExprIfThenElse {1468	fn can_cast(kind: SyntaxKind) -> bool {1469		kind == EXPR_IF_THEN_ELSE1470	}1471	fn cast(syntax: SyntaxNode) -> Option<Self> {1472		if Self::can_cast(syntax.kind()) {1473			Some(Self { syntax })1474		} else {1475			None1476		}1477	}1478	fn syntax(&self) -> &SyntaxNode {1479		&self.syntax1480	}1481}1482impl AstNode for TrueExpr {1483	fn can_cast(kind: SyntaxKind) -> bool {1484		kind == TRUE_EXPR1485	}1486	fn cast(syntax: SyntaxNode) -> Option<Self> {1487		if Self::can_cast(syntax.kind()) {1488			Some(Self { syntax })1489		} else {1490			None1491		}1492	}1493	fn syntax(&self) -> &SyntaxNode {1494		&self.syntax1495	}1496}1497impl AstNode for FalseExpr {1498	fn can_cast(kind: SyntaxKind) -> bool {1499		kind == FALSE_EXPR1500	}1501	fn cast(syntax: SyntaxNode) -> Option<Self> {1502		if Self::can_cast(syntax.kind()) {1503			Some(Self { syntax })1504		} else {1505			None1506		}1507	}1508	fn syntax(&self) -> &SyntaxNode {1509		&self.syntax1510	}1511}1512impl AstNode for ExprFunction {1513	fn can_cast(kind: SyntaxKind) -> bool {1514		kind == EXPR_FUNCTION1515	}1516	fn cast(syntax: SyntaxNode) -> Option<Self> {1517		if Self::can_cast(syntax.kind()) {1518			Some(Self { syntax })1519		} else {1520			None1521		}1522	}1523	fn syntax(&self) -> &SyntaxNode {1524		&self.syntax1525	}1526}1527impl AstNode for ParamsDesc {1528	fn can_cast(kind: SyntaxKind) -> bool {1529		kind == PARAMS_DESC1530	}1531	fn cast(syntax: SyntaxNode) -> Option<Self> {1532		if Self::can_cast(syntax.kind()) {1533			Some(Self { syntax })1534		} else {1535			None1536		}1537	}1538	fn syntax(&self) -> &SyntaxNode {1539		&self.syntax1540	}1541}1542impl AstNode for ExprAssert {1543	fn can_cast(kind: SyntaxKind) -> bool {1544		kind == EXPR_ASSERT1545	}1546	fn cast(syntax: SyntaxNode) -> Option<Self> {1547		if Self::can_cast(syntax.kind()) {1548			Some(Self { syntax })1549		} else {1550			None1551		}1552	}1553	fn syntax(&self) -> &SyntaxNode {1554		&self.syntax1555	}1556}1557impl AstNode for Assertion {1558	fn can_cast(kind: SyntaxKind) -> bool {1559		kind == ASSERTION1560	}1561	fn cast(syntax: SyntaxNode) -> Option<Self> {1562		if Self::can_cast(syntax.kind()) {1563			Some(Self { syntax })1564		} else {1565			None1566		}1567	}1568	fn syntax(&self) -> &SyntaxNode {1569		&self.syntax1570	}1571}1572impl AstNode for ExprError {1573	fn can_cast(kind: SyntaxKind) -> bool {1574		kind == EXPR_ERROR1575	}1576	fn cast(syntax: SyntaxNode) -> Option<Self> {1577		if Self::can_cast(syntax.kind()) {1578			Some(Self { syntax })1579		} else {1580			None1581		}1582	}1583	fn syntax(&self) -> &SyntaxNode {1584		&self.syntax1585	}1586}1587impl AstNode for SliceDescEnd {1588	fn can_cast(kind: SyntaxKind) -> bool {1589		kind == SLICE_DESC_END1590	}1591	fn cast(syntax: SyntaxNode) -> Option<Self> {1592		if Self::can_cast(syntax.kind()) {1593			Some(Self { syntax })1594		} else {1595			None1596		}1597	}1598	fn syntax(&self) -> &SyntaxNode {1599		&self.syntax1600	}1601}1602impl AstNode for SliceDescStep {1603	fn can_cast(kind: SyntaxKind) -> bool {1604		kind == SLICE_DESC_STEP1605	}1606	fn cast(syntax: SyntaxNode) -> Option<Self> {1607		if Self::can_cast(syntax.kind()) {1608			Some(Self { syntax })1609		} else {1610			None1611		}1612	}1613	fn syntax(&self) -> &SyntaxNode {1614		&self.syntax1615	}1616}1617impl AstNode for Arg {1618	fn can_cast(kind: SyntaxKind) -> bool {1619		kind == ARG1620	}1621	fn cast(syntax: SyntaxNode) -> Option<Self> {1622		if Self::can_cast(syntax.kind()) {1623			Some(Self { syntax })1624		} else {1625			None1626		}1627	}1628	fn syntax(&self) -> &SyntaxNode {1629		&self.syntax1630	}1631}1632impl AstNode for ObjBodyComp {1633	fn can_cast(kind: SyntaxKind) -> bool {1634		kind == OBJ_BODY_COMP1635	}1636	fn cast(syntax: SyntaxNode) -> Option<Self> {1637		if Self::can_cast(syntax.kind()) {1638			Some(Self { syntax })1639		} else {1640			None1641		}1642	}1643	fn syntax(&self) -> &SyntaxNode {1644		&self.syntax1645	}1646}1647impl AstNode for ObjLocalPostComma {1648	fn can_cast(kind: SyntaxKind) -> bool {1649		kind == OBJ_LOCAL_POST_COMMA1650	}1651	fn cast(syntax: SyntaxNode) -> Option<Self> {1652		if Self::can_cast(syntax.kind()) {1653			Some(Self { syntax })1654		} else {1655			None1656		}1657	}1658	fn syntax(&self) -> &SyntaxNode {1659		&self.syntax1660	}1661}1662impl AstNode for ObjLocalPreComma {1663	fn can_cast(kind: SyntaxKind) -> bool {1664		kind == OBJ_LOCAL_PRE_COMMA1665	}1666	fn cast(syntax: SyntaxNode) -> Option<Self> {1667		if Self::can_cast(syntax.kind()) {1668			Some(Self { syntax })1669		} else {1670			None1671		}1672	}1673	fn syntax(&self) -> &SyntaxNode {1674		&self.syntax1675	}1676}1677impl AstNode for ObjBodyMemberList {1678	fn can_cast(kind: SyntaxKind) -> bool {1679		kind == OBJ_BODY_MEMBER_LIST1680	}1681	fn cast(syntax: SyntaxNode) -> Option<Self> {1682		if Self::can_cast(syntax.kind()) {1683			Some(Self { syntax })1684		} else {1685			None1686		}1687	}1688	fn syntax(&self) -> &SyntaxNode {1689		&self.syntax1690	}1691}1692impl AstNode for ObjLocal {1693	fn can_cast(kind: SyntaxKind) -> bool {1694		kind == OBJ_LOCAL1695	}1696	fn cast(syntax: SyntaxNode) -> Option<Self> {1697		if Self::can_cast(syntax.kind()) {1698			Some(Self { syntax })1699		} else {1700			None1701		}1702	}1703	fn syntax(&self) -> &SyntaxNode {1704		&self.syntax1705	}1706}1707impl AstNode for MemberBindStmt {1708	fn can_cast(kind: SyntaxKind) -> bool {1709		kind == MEMBER_BIND_STMT1710	}1711	fn cast(syntax: SyntaxNode) -> Option<Self> {1712		if Self::can_cast(syntax.kind()) {1713			Some(Self { syntax })1714		} else {1715			None1716		}1717	}1718	fn syntax(&self) -> &SyntaxNode {1719		&self.syntax1720	}1721}1722impl AstNode for MemberAssertStmt {1723	fn can_cast(kind: SyntaxKind) -> bool {1724		kind == MEMBER_ASSERT_STMT1725	}1726	fn cast(syntax: SyntaxNode) -> Option<Self> {1727		if Self::can_cast(syntax.kind()) {1728			Some(Self { syntax })1729		} else {1730			None1731		}1732	}1733	fn syntax(&self) -> &SyntaxNode {1734		&self.syntax1735	}1736}1737impl AstNode for MemberField {1738	fn can_cast(kind: SyntaxKind) -> bool {1739		kind == MEMBER_FIELD1740	}1741	fn cast(syntax: SyntaxNode) -> Option<Self> {1742		if Self::can_cast(syntax.kind()) {1743			Some(Self { syntax })1744		} else {1745			None1746		}1747	}1748	fn syntax(&self) -> &SyntaxNode {1749		&self.syntax1750	}1751}1752impl AstNode for FieldNormal {1753	fn can_cast(kind: SyntaxKind) -> bool {1754		kind == FIELD_NORMAL1755	}1756	fn cast(syntax: SyntaxNode) -> Option<Self> {1757		if Self::can_cast(syntax.kind()) {1758			Some(Self { syntax })1759		} else {1760			None1761		}1762	}1763	fn syntax(&self) -> &SyntaxNode {1764		&self.syntax1765	}1766}1767impl AstNode for FieldMethod {1768	fn can_cast(kind: SyntaxKind) -> bool {1769		kind == FIELD_METHOD1770	}1771	fn cast(syntax: SyntaxNode) -> Option<Self> {1772		if Self::can_cast(syntax.kind()) {1773			Some(Self { syntax })1774		} else {1775			None1776		}1777	}1778	fn syntax(&self) -> &SyntaxNode {1779		&self.syntax1780	}1781}1782impl AstNode for FieldNameFixed {1783	fn can_cast(kind: SyntaxKind) -> bool {1784		kind == FIELD_NAME_FIXED1785	}1786	fn cast(syntax: SyntaxNode) -> Option<Self> {1787		if Self::can_cast(syntax.kind()) {1788			Some(Self { syntax })1789		} else {1790			None1791		}1792	}1793	fn syntax(&self) -> &SyntaxNode {1794		&self.syntax1795	}1796}1797impl AstNode for FieldNameDynamic {1798	fn can_cast(kind: SyntaxKind) -> bool {1799		kind == FIELD_NAME_DYNAMIC1800	}1801	fn cast(syntax: SyntaxNode) -> Option<Self> {1802		if Self::can_cast(syntax.kind()) {1803			Some(Self { syntax })1804		} else {1805			None1806		}1807	}1808	fn syntax(&self) -> &SyntaxNode {1809		&self.syntax1810	}1811}1812impl AstNode for ForSpec {1813	fn can_cast(kind: SyntaxKind) -> bool {1814		kind == FOR_SPEC1815	}1816	fn cast(syntax: SyntaxNode) -> Option<Self> {1817		if Self::can_cast(syntax.kind()) {1818			Some(Self { syntax })1819		} else {1820			None1821		}1822	}1823	fn syntax(&self) -> &SyntaxNode {1824		&self.syntax1825	}1826}1827impl AstNode for IfSpec {1828	fn can_cast(kind: SyntaxKind) -> bool {1829		kind == IF_SPEC1830	}1831	fn cast(syntax: SyntaxNode) -> Option<Self> {1832		if Self::can_cast(syntax.kind()) {1833			Some(Self { syntax })1834		} else {1835			None1836		}1837	}1838	fn syntax(&self) -> &SyntaxNode {1839		&self.syntax1840	}1841}1842impl AstNode for BindDestruct {1843	fn can_cast(kind: SyntaxKind) -> bool {1844		kind == BIND_DESTRUCT1845	}1846	fn cast(syntax: SyntaxNode) -> Option<Self> {1847		if Self::can_cast(syntax.kind()) {1848			Some(Self { syntax })1849		} else {1850			None1851		}1852	}1853	fn syntax(&self) -> &SyntaxNode {1854		&self.syntax1855	}1856}1857impl AstNode for BindFunction {1858	fn can_cast(kind: SyntaxKind) -> bool {1859		kind == BIND_FUNCTION1860	}1861	fn cast(syntax: SyntaxNode) -> Option<Self> {1862		if Self::can_cast(syntax.kind()) {1863			Some(Self { syntax })1864		} else {1865			None1866		}1867	}1868	fn syntax(&self) -> &SyntaxNode {1869		&self.syntax1870	}1871}1872impl AstNode for Param {1873	fn can_cast(kind: SyntaxKind) -> bool {1874		kind == PARAM1875	}1876	fn cast(syntax: SyntaxNode) -> Option<Self> {1877		if Self::can_cast(syntax.kind()) {1878			Some(Self { syntax })1879		} else {1880			None1881		}1882	}1883	fn syntax(&self) -> &SyntaxNode {1884		&self.syntax1885	}1886}1887impl AstNode for DestructFull {1888	fn can_cast(kind: SyntaxKind) -> bool {1889		kind == DESTRUCT_FULL1890	}1891	fn cast(syntax: SyntaxNode) -> Option<Self> {1892		if Self::can_cast(syntax.kind()) {1893			Some(Self { syntax })1894		} else {1895			None1896		}1897	}1898	fn syntax(&self) -> &SyntaxNode {1899		&self.syntax1900	}1901}1902impl AstNode for DestructSkip {1903	fn can_cast(kind: SyntaxKind) -> bool {1904		kind == DESTRUCT_SKIP1905	}1906	fn cast(syntax: SyntaxNode) -> Option<Self> {1907		if Self::can_cast(syntax.kind()) {1908			Some(Self { syntax })1909		} else {1910			None1911		}1912	}1913	fn syntax(&self) -> &SyntaxNode {1914		&self.syntax1915	}1916}1917impl AstNode for DestructArray {1918	fn can_cast(kind: SyntaxKind) -> bool {1919		kind == DESTRUCT_ARRAY1920	}1921	fn cast(syntax: SyntaxNode) -> Option<Self> {1922		if Self::can_cast(syntax.kind()) {1923			Some(Self { syntax })1924		} else {1925			None1926		}1927	}1928	fn syntax(&self) -> &SyntaxNode {1929		&self.syntax1930	}1931}1932impl AstNode for DestructObject {1933	fn can_cast(kind: SyntaxKind) -> bool {1934		kind == DESTRUCT_OBJECT1935	}1936	fn cast(syntax: SyntaxNode) -> Option<Self> {1937		if Self::can_cast(syntax.kind()) {1938			Some(Self { syntax })1939		} else {1940			None1941		}1942	}1943	fn syntax(&self) -> &SyntaxNode {1944		&self.syntax1945	}1946}1947impl AstNode for DestructObjectField {1948	fn can_cast(kind: SyntaxKind) -> bool {1949		kind == DESTRUCT_OBJECT_FIELD1950	}1951	fn cast(syntax: SyntaxNode) -> Option<Self> {1952		if Self::can_cast(syntax.kind()) {1953			Some(Self { syntax })1954		} else {1955			None1956		}1957	}1958	fn syntax(&self) -> &SyntaxNode {1959		&self.syntax1960	}1961}1962impl AstNode for DestructRest {1963	fn can_cast(kind: SyntaxKind) -> bool {1964		kind == DESTRUCT_REST1965	}1966	fn cast(syntax: SyntaxNode) -> Option<Self> {1967		if Self::can_cast(syntax.kind()) {1968			Some(Self { syntax })1969		} else {1970			None1971		}1972	}1973	fn syntax(&self) -> &SyntaxNode {1974		&self.syntax1975	}1976}1977impl AstNode for DestructArrayElement {1978	fn can_cast(kind: SyntaxKind) -> bool {1979		kind == DESTRUCT_ARRAY_ELEMENT1980	}1981	fn cast(syntax: SyntaxNode) -> Option<Self> {1982		if Self::can_cast(syntax.kind()) {1983			Some(Self { syntax })1984		} else {1985			None1986		}1987	}1988	fn syntax(&self) -> &SyntaxNode {1989		&self.syntax1990	}1991}1992impl From<ExprBinary> for Expr {1993	fn from(node: ExprBinary) -> Expr {1994		Expr::ExprBinary(node)1995	}1996}1997impl From<ExprUnary> for Expr {1998	fn from(node: ExprUnary) -> Expr {1999		Expr::ExprUnary(node)2000	}2001}2002impl From<ExprSlice> for Expr {2003	fn from(node: ExprSlice) -> Expr {2004		Expr::ExprSlice(node)2005	}2006}2007impl From<ExprIndex> for Expr {2008	fn from(node: ExprIndex) -> Expr {2009		Expr::ExprIndex(node)2010	}2011}2012impl From<ExprIndexExpr> for Expr {2013	fn from(node: ExprIndexExpr) -> Expr {2014		Expr::ExprIndexExpr(node)2015	}2016}2017impl From<ExprApply> for Expr {2018	fn from(node: ExprApply) -> Expr {2019		Expr::ExprApply(node)2020	}2021}2022impl From<ExprObjExtend> for Expr {2023	fn from(node: ExprObjExtend) -> Expr {2024		Expr::ExprObjExtend(node)2025	}2026}2027impl From<ExprParened> for Expr {2028	fn from(node: ExprParened) -> Expr {2029		Expr::ExprParened(node)2030	}2031}2032impl From<ExprIntrinsicThisFile> for Expr {2033	fn from(node: ExprIntrinsicThisFile) -> Expr {2034		Expr::ExprIntrinsicThisFile(node)2035	}2036}2037impl From<ExprIntrinsicId> for Expr {2038	fn from(node: ExprIntrinsicId) -> Expr {2039		Expr::ExprIntrinsicId(node)2040	}2041}2042impl From<ExprIntrinsic> for Expr {2043	fn from(node: ExprIntrinsic) -> Expr {2044		Expr::ExprIntrinsic(node)2045	}2046}2047impl From<ExprString> for Expr {2048	fn from(node: ExprString) -> Expr {2049		Expr::ExprString(node)2050	}2051}2052impl From<ExprNumber> for Expr {2053	fn from(node: ExprNumber) -> Expr {2054		Expr::ExprNumber(node)2055	}2056}2057impl From<ExprLiteral> for Expr {2058	fn from(node: ExprLiteral) -> Expr {2059		Expr::ExprLiteral(node)2060	}2061}2062impl From<ExprArray> for Expr {2063	fn from(node: ExprArray) -> Expr {2064		Expr::ExprArray(node)2065	}2066}2067impl From<ExprObject> for Expr {2068	fn from(node: ExprObject) -> Expr {2069		Expr::ExprObject(node)2070	}2071}2072impl From<ExprArrayComp> for Expr {2073	fn from(node: ExprArrayComp) -> Expr {2074		Expr::ExprArrayComp(node)2075	}2076}2077impl From<ExprImport> for Expr {2078	fn from(node: ExprImport) -> Expr {2079		Expr::ExprImport(node)2080	}2081}2082impl From<ExprVar> for Expr {2083	fn from(node: ExprVar) -> Expr {2084		Expr::ExprVar(node)2085	}2086}2087impl From<ExprLocal> for Expr {2088	fn from(node: ExprLocal) -> Expr {2089		Expr::ExprLocal(node)2090	}2091}2092impl From<ExprIfThenElse> for Expr {2093	fn from(node: ExprIfThenElse) -> Expr {2094		Expr::ExprIfThenElse(node)2095	}2096}2097impl From<ExprFunction> for Expr {2098	fn from(node: ExprFunction) -> Expr {2099		Expr::ExprFunction(node)2100	}2101}2102impl From<ExprAssert> for Expr {2103	fn from(node: ExprAssert) -> Expr {2104		Expr::ExprAssert(node)2105	}2106}2107impl From<ExprError> for Expr {2108	fn from(node: ExprError) -> Expr {2109		Expr::ExprError(node)2110	}2111}2112impl AstNode for Expr {2113	fn can_cast(kind: SyntaxKind) -> bool {2114		match kind {2115			EXPR_BINARY2116			| EXPR_UNARY2117			| EXPR_SLICE2118			| EXPR_INDEX2119			| EXPR_INDEX_EXPR2120			| EXPR_APPLY2121			| EXPR_OBJ_EXTEND2122			| EXPR_PARENED2123			| EXPR_INTRINSIC_THIS_FILE2124			| EXPR_INTRINSIC_ID2125			| EXPR_INTRINSIC2126			| EXPR_STRING2127			| EXPR_NUMBER2128			| EXPR_LITERAL2129			| EXPR_ARRAY2130			| EXPR_OBJECT2131			| EXPR_ARRAY_COMP2132			| EXPR_IMPORT2133			| EXPR_VAR2134			| EXPR_LOCAL2135			| EXPR_IF_THEN_ELSE2136			| EXPR_FUNCTION2137			| EXPR_ASSERT2138			| EXPR_ERROR => true,2139			_ => false,2140		}2141	}2142	fn cast(syntax: SyntaxNode) -> Option<Self> {2143		let res = match syntax.kind() {2144			EXPR_BINARY => Expr::ExprBinary(ExprBinary { syntax }),2145			EXPR_UNARY => Expr::ExprUnary(ExprUnary { syntax }),2146			EXPR_SLICE => Expr::ExprSlice(ExprSlice { syntax }),2147			EXPR_INDEX => Expr::ExprIndex(ExprIndex { syntax }),2148			EXPR_INDEX_EXPR => Expr::ExprIndexExpr(ExprIndexExpr { syntax }),2149			EXPR_APPLY => Expr::ExprApply(ExprApply { syntax }),2150			EXPR_OBJ_EXTEND => Expr::ExprObjExtend(ExprObjExtend { syntax }),2151			EXPR_PARENED => Expr::ExprParened(ExprParened { syntax }),2152			EXPR_INTRINSIC_THIS_FILE => {2153				Expr::ExprIntrinsicThisFile(ExprIntrinsicThisFile { syntax })2154			}2155			EXPR_INTRINSIC_ID => Expr::ExprIntrinsicId(ExprIntrinsicId { syntax }),2156			EXPR_INTRINSIC => Expr::ExprIntrinsic(ExprIntrinsic { syntax }),2157			EXPR_STRING => Expr::ExprString(ExprString { syntax }),2158			EXPR_NUMBER => Expr::ExprNumber(ExprNumber { syntax }),2159			EXPR_LITERAL => Expr::ExprLiteral(ExprLiteral { syntax }),2160			EXPR_ARRAY => Expr::ExprArray(ExprArray { syntax }),2161			EXPR_OBJECT => Expr::ExprObject(ExprObject { syntax }),2162			EXPR_ARRAY_COMP => Expr::ExprArrayComp(ExprArrayComp { syntax }),2163			EXPR_IMPORT => Expr::ExprImport(ExprImport { syntax }),2164			EXPR_VAR => Expr::ExprVar(ExprVar { syntax }),2165			EXPR_LOCAL => Expr::ExprLocal(ExprLocal { syntax }),2166			EXPR_IF_THEN_ELSE => Expr::ExprIfThenElse(ExprIfThenElse { syntax }),2167			EXPR_FUNCTION => Expr::ExprFunction(ExprFunction { syntax }),2168			EXPR_ASSERT => Expr::ExprAssert(ExprAssert { syntax }),2169			EXPR_ERROR => Expr::ExprError(ExprError { syntax }),2170			_ => return None,2171		};2172		Some(res)2173	}2174	fn syntax(&self) -> &SyntaxNode {2175		match self {2176			Expr::ExprBinary(it) => &it.syntax,2177			Expr::ExprUnary(it) => &it.syntax,2178			Expr::ExprSlice(it) => &it.syntax,2179			Expr::ExprIndex(it) => &it.syntax,2180			Expr::ExprIndexExpr(it) => &it.syntax,2181			Expr::ExprApply(it) => &it.syntax,2182			Expr::ExprObjExtend(it) => &it.syntax,2183			Expr::ExprParened(it) => &it.syntax,2184			Expr::ExprIntrinsicThisFile(it) => &it.syntax,2185			Expr::ExprIntrinsicId(it) => &it.syntax,2186			Expr::ExprIntrinsic(it) => &it.syntax,2187			Expr::ExprString(it) => &it.syntax,2188			Expr::ExprNumber(it) => &it.syntax,2189			Expr::ExprLiteral(it) => &it.syntax,2190			Expr::ExprArray(it) => &it.syntax,2191			Expr::ExprObject(it) => &it.syntax,2192			Expr::ExprArrayComp(it) => &it.syntax,2193			Expr::ExprImport(it) => &it.syntax,2194			Expr::ExprVar(it) => &it.syntax,2195			Expr::ExprLocal(it) => &it.syntax,2196			Expr::ExprIfThenElse(it) => &it.syntax,2197			Expr::ExprFunction(it) => &it.syntax,2198			Expr::ExprAssert(it) => &it.syntax,2199			Expr::ExprError(it) => &it.syntax,2200		}2201	}2202}2203impl From<ObjBodyComp> for ObjBody {2204	fn from(node: ObjBodyComp) -> ObjBody {2205		ObjBody::ObjBodyComp(node)2206	}2207}2208impl From<ObjBodyMemberList> for ObjBody {2209	fn from(node: ObjBodyMemberList) -> ObjBody {2210		ObjBody::ObjBodyMemberList(node)2211	}2212}2213impl AstNode for ObjBody {2214	fn can_cast(kind: SyntaxKind) -> bool {2215		match kind {2216			OBJ_BODY_COMP | OBJ_BODY_MEMBER_LIST => true,2217			_ => false,2218		}2219	}2220	fn cast(syntax: SyntaxNode) -> Option<Self> {2221		let res = match syntax.kind() {2222			OBJ_BODY_COMP => ObjBody::ObjBodyComp(ObjBodyComp { syntax }),2223			OBJ_BODY_MEMBER_LIST => ObjBody::ObjBodyMemberList(ObjBodyMemberList { syntax }),2224			_ => return None,2225		};2226		Some(res)2227	}2228	fn syntax(&self) -> &SyntaxNode {2229		match self {2230			ObjBody::ObjBodyComp(it) => &it.syntax,2231			ObjBody::ObjBodyMemberList(it) => &it.syntax,2232		}2233	}2234}2235impl From<ForSpec> for CompSpec {2236	fn from(node: ForSpec) -> CompSpec {2237		CompSpec::ForSpec(node)2238	}2239}2240impl From<IfSpec> for CompSpec {2241	fn from(node: IfSpec) -> CompSpec {2242		CompSpec::IfSpec(node)2243	}2244}2245impl AstNode for CompSpec {2246	fn can_cast(kind: SyntaxKind) -> bool {2247		match kind {2248			FOR_SPEC | IF_SPEC => true,2249			_ => false,2250		}2251	}2252	fn cast(syntax: SyntaxNode) -> Option<Self> {2253		let res = match syntax.kind() {2254			FOR_SPEC => CompSpec::ForSpec(ForSpec { syntax }),2255			IF_SPEC => CompSpec::IfSpec(IfSpec { syntax }),2256			_ => return None,2257		};2258		Some(res)2259	}2260	fn syntax(&self) -> &SyntaxNode {2261		match self {2262			CompSpec::ForSpec(it) => &it.syntax,2263			CompSpec::IfSpec(it) => &it.syntax,2264		}2265	}2266}2267impl From<BindDestruct> for Bind {2268	fn from(node: BindDestruct) -> Bind {2269		Bind::BindDestruct(node)2270	}2271}2272impl From<BindFunction> for Bind {2273	fn from(node: BindFunction) -> Bind {2274		Bind::BindFunction(node)2275	}2276}2277impl AstNode for Bind {2278	fn can_cast(kind: SyntaxKind) -> bool {2279		match kind {2280			BIND_DESTRUCT | BIND_FUNCTION => true,2281			_ => false,2282		}2283	}2284	fn cast(syntax: SyntaxNode) -> Option<Self> {2285		let res = match syntax.kind() {2286			BIND_DESTRUCT => Bind::BindDestruct(BindDestruct { syntax }),2287			BIND_FUNCTION => Bind::BindFunction(BindFunction { syntax }),2288			_ => return None,2289		};2290		Some(res)2291	}2292	fn syntax(&self) -> &SyntaxNode {2293		match self {2294			Bind::BindDestruct(it) => &it.syntax,2295			Bind::BindFunction(it) => &it.syntax,2296		}2297	}2298}2299impl From<MemberBindStmt> for Member {2300	fn from(node: MemberBindStmt) -> Member {2301		Member::MemberBindStmt(node)2302	}2303}2304impl From<MemberAssertStmt> for Member {2305	fn from(node: MemberAssertStmt) -> Member {2306		Member::MemberAssertStmt(node)2307	}2308}2309impl From<MemberField> for Member {2310	fn from(node: MemberField) -> Member {2311		Member::MemberField(node)2312	}2313}2314impl AstNode for Member {2315	fn can_cast(kind: SyntaxKind) -> bool {2316		match kind {2317			MEMBER_BIND_STMT | MEMBER_ASSERT_STMT | MEMBER_FIELD => true,2318			_ => false,2319		}2320	}2321	fn cast(syntax: SyntaxNode) -> Option<Self> {2322		let res = match syntax.kind() {2323			MEMBER_BIND_STMT => Member::MemberBindStmt(MemberBindStmt { syntax }),2324			MEMBER_ASSERT_STMT => Member::MemberAssertStmt(MemberAssertStmt { syntax }),2325			MEMBER_FIELD => Member::MemberField(MemberField { syntax }),2326			_ => return None,2327		};2328		Some(res)2329	}2330	fn syntax(&self) -> &SyntaxNode {2331		match self {2332			Member::MemberBindStmt(it) => &it.syntax,2333			Member::MemberAssertStmt(it) => &it.syntax,2334			Member::MemberField(it) => &it.syntax,2335		}2336	}2337}2338impl From<FieldNormal> for Field {2339	fn from(node: FieldNormal) -> Field {2340		Field::FieldNormal(node)2341	}2342}2343impl From<FieldMethod> for Field {2344	fn from(node: FieldMethod) -> Field {2345		Field::FieldMethod(node)2346	}2347}2348impl AstNode for Field {2349	fn can_cast(kind: SyntaxKind) -> bool {2350		match kind {2351			FIELD_NORMAL | FIELD_METHOD => true,2352			_ => false,2353		}2354	}2355	fn cast(syntax: SyntaxNode) -> Option<Self> {2356		let res = match syntax.kind() {2357			FIELD_NORMAL => Field::FieldNormal(FieldNormal { syntax }),2358			FIELD_METHOD => Field::FieldMethod(FieldMethod { syntax }),2359			_ => return None,2360		};2361		Some(res)2362	}2363	fn syntax(&self) -> &SyntaxNode {2364		match self {2365			Field::FieldNormal(it) => &it.syntax,2366			Field::FieldMethod(it) => &it.syntax,2367		}2368	}2369}2370impl From<FieldNameFixed> for FieldName {2371	fn from(node: FieldNameFixed) -> FieldName {2372		FieldName::FieldNameFixed(node)2373	}2374}2375impl From<FieldNameDynamic> for FieldName {2376	fn from(node: FieldNameDynamic) -> FieldName {2377		FieldName::FieldNameDynamic(node)2378	}2379}2380impl AstNode for FieldName {2381	fn can_cast(kind: SyntaxKind) -> bool {2382		match kind {2383			FIELD_NAME_FIXED | FIELD_NAME_DYNAMIC => true,2384			_ => false,2385		}2386	}2387	fn cast(syntax: SyntaxNode) -> Option<Self> {2388		let res = match syntax.kind() {2389			FIELD_NAME_FIXED => FieldName::FieldNameFixed(FieldNameFixed { syntax }),2390			FIELD_NAME_DYNAMIC => FieldName::FieldNameDynamic(FieldNameDynamic { syntax }),2391			_ => return None,2392		};2393		Some(res)2394	}2395	fn syntax(&self) -> &SyntaxNode {2396		match self {2397			FieldName::FieldNameFixed(it) => &it.syntax,2398			FieldName::FieldNameDynamic(it) => &it.syntax,2399		}2400	}2401}2402impl From<DestructFull> for Destruct {2403	fn from(node: DestructFull) -> Destruct {2404		Destruct::DestructFull(node)2405	}2406}2407impl From<DestructSkip> for Destruct {2408	fn from(node: DestructSkip) -> Destruct {2409		Destruct::DestructSkip(node)2410	}2411}2412impl From<DestructArray> for Destruct {2413	fn from(node: DestructArray) -> Destruct {2414		Destruct::DestructArray(node)2415	}2416}2417impl From<DestructObject> for Destruct {2418	fn from(node: DestructObject) -> Destruct {2419		Destruct::DestructObject(node)2420	}2421}2422impl AstNode for Destruct {2423	fn can_cast(kind: SyntaxKind) -> bool {2424		match kind {2425			DESTRUCT_FULL | DESTRUCT_SKIP | DESTRUCT_ARRAY | DESTRUCT_OBJECT => true,2426			_ => false,2427		}2428	}2429	fn cast(syntax: SyntaxNode) -> Option<Self> {2430		let res = match syntax.kind() {2431			DESTRUCT_FULL => Destruct::DestructFull(DestructFull { syntax }),2432			DESTRUCT_SKIP => Destruct::DestructSkip(DestructSkip { syntax }),2433			DESTRUCT_ARRAY => Destruct::DestructArray(DestructArray { syntax }),2434			DESTRUCT_OBJECT => Destruct::DestructObject(DestructObject { syntax }),2435			_ => return None,2436		};2437		Some(res)2438	}2439	fn syntax(&self) -> &SyntaxNode {2440		match self {2441			Destruct::DestructFull(it) => &it.syntax,2442			Destruct::DestructSkip(it) => &it.syntax,2443			Destruct::DestructArray(it) => &it.syntax,2444			Destruct::DestructObject(it) => &it.syntax,2445		}2446	}2447}2448impl From<DestructArrayElement> for DestructArrayPart {2449	fn from(node: DestructArrayElement) -> DestructArrayPart {2450		DestructArrayPart::DestructArrayElement(node)2451	}2452}2453impl From<DestructRest> for DestructArrayPart {2454	fn from(node: DestructRest) -> DestructArrayPart {2455		DestructArrayPart::DestructRest(node)2456	}2457}2458impl AstNode for DestructArrayPart {2459	fn can_cast(kind: SyntaxKind) -> bool {2460		match kind {2461			DESTRUCT_ARRAY_ELEMENT | DESTRUCT_REST => true,2462			_ => false,2463		}2464	}2465	fn cast(syntax: SyntaxNode) -> Option<Self> {2466		let res = match syntax.kind() {2467			DESTRUCT_ARRAY_ELEMENT => {2468				DestructArrayPart::DestructArrayElement(DestructArrayElement { syntax })2469			}2470			DESTRUCT_REST => DestructArrayPart::DestructRest(DestructRest { syntax }),2471			_ => return None,2472		};2473		Some(res)2474	}2475	fn syntax(&self) -> &SyntaxNode {2476		match self {2477			DestructArrayPart::DestructArrayElement(it) => &it.syntax,2478			DestructArrayPart::DestructRest(it) => &it.syntax,2479		}2480	}2481}2482impl AstToken for BinaryOperator {2483	fn can_cast(kind: SyntaxKind) -> bool {2484		match kind {2485			OR | AND | BIT_OR | BIT_XOR | BIT_AND | EQ | NE | LT | GT | LE | GE | IN_KW | LHS2486			| RHS | PLUS | MINUS | MUL | DIV | MODULO | ERROR_NO_OPERATOR => true,2487			_ => false,2488		}2489	}2490	fn cast(syntax: SyntaxToken) -> Option<Self> {2491		let res = match syntax.kind() {2492			OR => BinaryOperator {2493				syntax,2494				kind: BinaryOperatorKind::Or,2495			},2496			AND => BinaryOperator {2497				syntax,2498				kind: BinaryOperatorKind::And,2499			},2500			BIT_OR => BinaryOperator {2501				syntax,2502				kind: BinaryOperatorKind::BitOr,2503			},2504			BIT_XOR => BinaryOperator {2505				syntax,2506				kind: BinaryOperatorKind::BitXor,2507			},2508			BIT_AND => BinaryOperator {2509				syntax,2510				kind: BinaryOperatorKind::BitAnd,2511			},2512			EQ => BinaryOperator {2513				syntax,2514				kind: BinaryOperatorKind::Eq,2515			},2516			NE => BinaryOperator {2517				syntax,2518				kind: BinaryOperatorKind::Ne,2519			},2520			LT => BinaryOperator {2521				syntax,2522				kind: BinaryOperatorKind::Lt,2523			},2524			GT => BinaryOperator {2525				syntax,2526				kind: BinaryOperatorKind::Gt,2527			},2528			LE => BinaryOperator {2529				syntax,2530				kind: BinaryOperatorKind::Le,2531			},2532			GE => BinaryOperator {2533				syntax,2534				kind: BinaryOperatorKind::Ge,2535			},2536			IN_KW => BinaryOperator {2537				syntax,2538				kind: BinaryOperatorKind::InKw,2539			},2540			LHS => BinaryOperator {2541				syntax,2542				kind: BinaryOperatorKind::Lhs,2543			},2544			RHS => BinaryOperator {2545				syntax,2546				kind: BinaryOperatorKind::Rhs,2547			},2548			PLUS => BinaryOperator {2549				syntax,2550				kind: BinaryOperatorKind::Plus,2551			},2552			MINUS => BinaryOperator {2553				syntax,2554				kind: BinaryOperatorKind::Minus,2555			},2556			MUL => BinaryOperator {2557				syntax,2558				kind: BinaryOperatorKind::Mul,2559			},2560			DIV => BinaryOperator {2561				syntax,2562				kind: BinaryOperatorKind::Div,2563			},2564			MODULO => BinaryOperator {2565				syntax,2566				kind: BinaryOperatorKind::Modulo,2567			},2568			ERROR_NO_OPERATOR => BinaryOperator {2569				syntax,2570				kind: BinaryOperatorKind::ErrorNoOperator,2571			},2572			_ => return None,2573		};2574		Some(res)2575	}2576	fn syntax(&self) -> &SyntaxToken {2577		&self.syntax2578	}2579}2580impl BinaryOperator {2581	pub fn kind(&self) -> BinaryOperatorKind {2582		self.kind2583	}2584}2585impl std::fmt::Display for BinaryOperator {2586	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2587		std::fmt::Display::fmt(self.syntax(), f)2588	}2589}2590impl AstToken for UnaryOperator {2591	fn can_cast(kind: SyntaxKind) -> bool {2592		match kind {2593			MINUS | NOT | BIT_NOT => true,2594			_ => false,2595		}2596	}2597	fn cast(syntax: SyntaxToken) -> Option<Self> {2598		let res = match syntax.kind() {2599			MINUS => UnaryOperator {2600				syntax,2601				kind: UnaryOperatorKind::Minus,2602			},2603			NOT => UnaryOperator {2604				syntax,2605				kind: UnaryOperatorKind::Not,2606			},2607			BIT_NOT => UnaryOperator {2608				syntax,2609				kind: UnaryOperatorKind::BitNot,2610			},2611			_ => return None,2612		};2613		Some(res)2614	}2615	fn syntax(&self) -> &SyntaxToken {2616		&self.syntax2617	}2618}2619impl UnaryOperator {2620	pub fn kind(&self) -> UnaryOperatorKind {2621		self.kind2622	}2623}2624impl std::fmt::Display for UnaryOperator {2625	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2626		std::fmt::Display::fmt(self.syntax(), f)2627	}2628}2629impl AstToken for Literal {2630	fn can_cast(kind: SyntaxKind) -> bool {2631		match kind {2632			NULL_KW | TRUE_KW | FALSE_KW | SELF_KW | DOLLAR | SUPER_KW => true,2633			_ => false,2634		}2635	}2636	fn cast(syntax: SyntaxToken) -> Option<Self> {2637		let res = match syntax.kind() {2638			NULL_KW => Literal {2639				syntax,2640				kind: LiteralKind::NullKw,2641			},2642			TRUE_KW => Literal {2643				syntax,2644				kind: LiteralKind::TrueKw,2645			},2646			FALSE_KW => Literal {2647				syntax,2648				kind: LiteralKind::FalseKw,2649			},2650			SELF_KW => Literal {2651				syntax,2652				kind: LiteralKind::SelfKw,2653			},2654			DOLLAR => Literal {2655				syntax,2656				kind: LiteralKind::Dollar,2657			},2658			SUPER_KW => Literal {2659				syntax,2660				kind: LiteralKind::SuperKw,2661			},2662			_ => return None,2663		};2664		Some(res)2665	}2666	fn syntax(&self) -> &SyntaxToken {2667		&self.syntax2668	}2669}2670impl Literal {2671	pub fn kind(&self) -> LiteralKind {2672		self.kind2673	}2674}2675impl std::fmt::Display for Literal {2676	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2677		std::fmt::Display::fmt(self.syntax(), f)2678	}2679}2680impl AstToken for String {2681	fn can_cast(kind: SyntaxKind) -> bool {2682		match kind {2683			STRING_DOUBLE2684			| STRING_SINGLE2685			| STRING_DOUBLE_VERBATIM2686			| STRING_SINGLE_VERBATIM2687			| STRING_BLOCK => true,2688			_ => false,2689		}2690	}2691	fn cast(syntax: SyntaxToken) -> Option<Self> {2692		let res = match syntax.kind() {2693			STRING_DOUBLE => String {2694				syntax,2695				kind: StringKind::StringDouble,2696			},2697			STRING_SINGLE => String {2698				syntax,2699				kind: StringKind::StringSingle,2700			},2701			STRING_DOUBLE_VERBATIM => String {2702				syntax,2703				kind: StringKind::StringDoubleVerbatim,2704			},2705			STRING_SINGLE_VERBATIM => String {2706				syntax,2707				kind: StringKind::StringSingleVerbatim,2708			},2709			STRING_BLOCK => String {2710				syntax,2711				kind: StringKind::StringBlock,2712			},2713			_ => return None,2714		};2715		Some(res)2716	}2717	fn syntax(&self) -> &SyntaxToken {2718		&self.syntax2719	}2720}2721impl String {2722	pub fn kind(&self) -> StringKind {2723		self.kind2724	}2725}2726impl std::fmt::Display for String {2727	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2728		std::fmt::Display::fmt(self.syntax(), f)2729	}2730}2731impl AstToken for Number {2732	fn can_cast(kind: SyntaxKind) -> bool {2733		match kind {2734			FLOAT | META_FORCE_ENUM => true,2735			_ => false,2736		}2737	}2738	fn cast(syntax: SyntaxToken) -> Option<Self> {2739		let res = match syntax.kind() {2740			FLOAT => Number {2741				syntax,2742				kind: NumberKind::Float,2743			},2744			META_FORCE_ENUM => Number {2745				syntax,2746				kind: NumberKind::MetaForceEnum,2747			},2748			_ => return None,2749		};2750		Some(res)2751	}2752	fn syntax(&self) -> &SyntaxToken {2753		&self.syntax2754	}2755}2756impl Number {2757	pub fn kind(&self) -> NumberKind {2758		self.kind2759	}2760}2761impl std::fmt::Display for Number {2762	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2763		std::fmt::Display::fmt(self.syntax(), f)2764	}2765}2766impl AstToken for ImportKind {2767	fn can_cast(kind: SyntaxKind) -> bool {2768		match kind {2769			IMPORTSTR_KW | IMPORTBIN_KW | IMPORT_KW => true,2770			_ => false,2771		}2772	}2773	fn cast(syntax: SyntaxToken) -> Option<Self> {2774		let res = match syntax.kind() {2775			IMPORTSTR_KW => ImportKind {2776				syntax,2777				kind: ImportKindKind::ImportstrKw,2778			},2779			IMPORTBIN_KW => ImportKind {2780				syntax,2781				kind: ImportKindKind::ImportbinKw,2782			},2783			IMPORT_KW => ImportKind {2784				syntax,2785				kind: ImportKindKind::ImportKw,2786			},2787			_ => return None,2788		};2789		Some(res)2790	}2791	fn syntax(&self) -> &SyntaxToken {2792		&self.syntax2793	}2794}2795impl ImportKind {2796	pub fn kind(&self) -> ImportKindKind {2797		self.kind2798	}2799}2800impl std::fmt::Display for ImportKind {2801	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2802		std::fmt::Display::fmt(self.syntax(), f)2803	}2804}2805impl AstToken for Visibility {2806	fn can_cast(kind: SyntaxKind) -> bool {2807		match kind {2808			COLONCOLONCOLON | COLONCOLON | COLON => true,2809			_ => false,2810		}2811	}2812	fn cast(syntax: SyntaxToken) -> Option<Self> {2813		let res = match syntax.kind() {2814			COLONCOLONCOLON => Visibility {2815				syntax,2816				kind: VisibilityKind::Coloncoloncolon,2817			},2818			COLONCOLON => Visibility {2819				syntax,2820				kind: VisibilityKind::Coloncolon,2821			},2822			COLON => Visibility {2823				syntax,2824				kind: VisibilityKind::Colon,2825			},2826			_ => return None,2827		};2828		Some(res)2829	}2830	fn syntax(&self) -> &SyntaxToken {2831		&self.syntax2832	}2833}2834impl Visibility {2835	pub fn kind(&self) -> VisibilityKind {2836		self.kind2837	}2838}2839impl std::fmt::Display for Visibility {2840	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2841		std::fmt::Display::fmt(self.syntax(), f)2842	}2843}2844impl std::fmt::Display for Expr {2845	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2846		std::fmt::Display::fmt(self.syntax(), f)2847	}2848}2849impl std::fmt::Display for ObjBody {2850	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2851		std::fmt::Display::fmt(self.syntax(), f)2852	}2853}2854impl std::fmt::Display for CompSpec {2855	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2856		std::fmt::Display::fmt(self.syntax(), f)2857	}2858}2859impl std::fmt::Display for Bind {2860	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2861		std::fmt::Display::fmt(self.syntax(), f)2862	}2863}2864impl std::fmt::Display for Member {2865	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2866		std::fmt::Display::fmt(self.syntax(), f)2867	}2868}2869impl std::fmt::Display for Field {2870	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2871		std::fmt::Display::fmt(self.syntax(), f)2872	}2873}2874impl std::fmt::Display for FieldName {2875	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2876		std::fmt::Display::fmt(self.syntax(), f)2877	}2878}2879impl std::fmt::Display for Destruct {2880	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2881		std::fmt::Display::fmt(self.syntax(), f)2882	}2883}2884impl std::fmt::Display for DestructArrayPart {2885	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2886		std::fmt::Display::fmt(self.syntax(), f)2887	}2888}2889impl std::fmt::Display for SourceFile {2890	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2891		std::fmt::Display::fmt(self.syntax(), f)2892	}2893}2894impl std::fmt::Display for ExprBinary {2895	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2896		std::fmt::Display::fmt(self.syntax(), f)2897	}2898}2899impl std::fmt::Display for LhsExpr {2900	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2901		std::fmt::Display::fmt(self.syntax(), f)2902	}2903}2904impl std::fmt::Display for ExprUnary {2905	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2906		std::fmt::Display::fmt(self.syntax(), f)2907	}2908}2909impl std::fmt::Display for ExprSlice {2910	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2911		std::fmt::Display::fmt(self.syntax(), f)2912	}2913}2914impl std::fmt::Display for SliceDesc {2915	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2916		std::fmt::Display::fmt(self.syntax(), f)2917	}2918}2919impl std::fmt::Display for ExprIndex {2920	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2921		std::fmt::Display::fmt(self.syntax(), f)2922	}2923}2924impl std::fmt::Display for Name {2925	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2926		std::fmt::Display::fmt(self.syntax(), f)2927	}2928}2929impl std::fmt::Display for ExprIndexExpr {2930	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2931		std::fmt::Display::fmt(self.syntax(), f)2932	}2933}2934impl std::fmt::Display for ExprApply {2935	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2936		std::fmt::Display::fmt(self.syntax(), f)2937	}2938}2939impl std::fmt::Display for ArgsDesc {2940	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2941		std::fmt::Display::fmt(self.syntax(), f)2942	}2943}2944impl std::fmt::Display for ExprObjExtend {2945	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2946		std::fmt::Display::fmt(self.syntax(), f)2947	}2948}2949impl std::fmt::Display for ExprParened {2950	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2951		std::fmt::Display::fmt(self.syntax(), f)2952	}2953}2954impl std::fmt::Display for ExprLiteral {2955	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2956		std::fmt::Display::fmt(self.syntax(), f)2957	}2958}2959impl std::fmt::Display for ExprIntrinsicThisFile {2960	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2961		std::fmt::Display::fmt(self.syntax(), f)2962	}2963}2964impl std::fmt::Display for ExprIntrinsicId {2965	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2966		std::fmt::Display::fmt(self.syntax(), f)2967	}2968}2969impl std::fmt::Display for ExprIntrinsic {2970	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2971		std::fmt::Display::fmt(self.syntax(), f)2972	}2973}2974impl std::fmt::Display for ExprString {2975	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2976		std::fmt::Display::fmt(self.syntax(), f)2977	}2978}2979impl std::fmt::Display for ExprNumber {2980	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2981		std::fmt::Display::fmt(self.syntax(), f)2982	}2983}2984impl std::fmt::Display for ExprArray {2985	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2986		std::fmt::Display::fmt(self.syntax(), f)2987	}2988}2989impl std::fmt::Display for ExprObject {2990	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2991		std::fmt::Display::fmt(self.syntax(), f)2992	}2993}2994impl std::fmt::Display for ExprArrayComp {2995	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2996		std::fmt::Display::fmt(self.syntax(), f)2997	}2998}2999impl std::fmt::Display for ExprImport {3000	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3001		std::fmt::Display::fmt(self.syntax(), f)3002	}3003}3004impl std::fmt::Display for ExprVar {3005	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3006		std::fmt::Display::fmt(self.syntax(), f)3007	}3008}3009impl std::fmt::Display for ExprLocal {3010	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3011		std::fmt::Display::fmt(self.syntax(), f)3012	}3013}3014impl std::fmt::Display for ExprIfThenElse {3015	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3016		std::fmt::Display::fmt(self.syntax(), f)3017	}3018}3019impl std::fmt::Display for TrueExpr {3020	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3021		std::fmt::Display::fmt(self.syntax(), f)3022	}3023}3024impl std::fmt::Display for FalseExpr {3025	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3026		std::fmt::Display::fmt(self.syntax(), f)3027	}3028}3029impl std::fmt::Display for ExprFunction {3030	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3031		std::fmt::Display::fmt(self.syntax(), f)3032	}3033}3034impl std::fmt::Display for ParamsDesc {3035	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3036		std::fmt::Display::fmt(self.syntax(), f)3037	}3038}3039impl std::fmt::Display for ExprAssert {3040	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3041		std::fmt::Display::fmt(self.syntax(), f)3042	}3043}3044impl std::fmt::Display for Assertion {3045	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3046		std::fmt::Display::fmt(self.syntax(), f)3047	}3048}3049impl std::fmt::Display for ExprError {3050	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3051		std::fmt::Display::fmt(self.syntax(), f)3052	}3053}3054impl std::fmt::Display for SliceDescEnd {3055	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3056		std::fmt::Display::fmt(self.syntax(), f)3057	}3058}3059impl std::fmt::Display for SliceDescStep {3060	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3061		std::fmt::Display::fmt(self.syntax(), f)3062	}3063}3064impl std::fmt::Display for Arg {3065	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3066		std::fmt::Display::fmt(self.syntax(), f)3067	}3068}3069impl std::fmt::Display for ObjBodyComp {3070	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3071		std::fmt::Display::fmt(self.syntax(), f)3072	}3073}3074impl std::fmt::Display for ObjLocalPostComma {3075	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3076		std::fmt::Display::fmt(self.syntax(), f)3077	}3078}3079impl std::fmt::Display for ObjLocalPreComma {3080	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3081		std::fmt::Display::fmt(self.syntax(), f)3082	}3083}3084impl std::fmt::Display for ObjBodyMemberList {3085	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3086		std::fmt::Display::fmt(self.syntax(), f)3087	}3088}3089impl std::fmt::Display for ObjLocal {3090	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3091		std::fmt::Display::fmt(self.syntax(), f)3092	}3093}3094impl std::fmt::Display for MemberBindStmt {3095	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3096		std::fmt::Display::fmt(self.syntax(), f)3097	}3098}3099impl std::fmt::Display for MemberAssertStmt {3100	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3101		std::fmt::Display::fmt(self.syntax(), f)3102	}3103}3104impl std::fmt::Display for MemberField {3105	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3106		std::fmt::Display::fmt(self.syntax(), f)3107	}3108}3109impl std::fmt::Display for FieldNormal {3110	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3111		std::fmt::Display::fmt(self.syntax(), f)3112	}3113}3114impl std::fmt::Display for FieldMethod {3115	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3116		std::fmt::Display::fmt(self.syntax(), f)3117	}3118}3119impl std::fmt::Display for FieldNameFixed {3120	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3121		std::fmt::Display::fmt(self.syntax(), f)3122	}3123}3124impl std::fmt::Display for FieldNameDynamic {3125	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3126		std::fmt::Display::fmt(self.syntax(), f)3127	}3128}3129impl std::fmt::Display for ForSpec {3130	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3131		std::fmt::Display::fmt(self.syntax(), f)3132	}3133}3134impl std::fmt::Display for IfSpec {3135	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3136		std::fmt::Display::fmt(self.syntax(), f)3137	}3138}3139impl std::fmt::Display for BindDestruct {3140	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3141		std::fmt::Display::fmt(self.syntax(), f)3142	}3143}3144impl std::fmt::Display for BindFunction {3145	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3146		std::fmt::Display::fmt(self.syntax(), f)3147	}3148}3149impl std::fmt::Display for Param {3150	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3151		std::fmt::Display::fmt(self.syntax(), f)3152	}3153}3154impl std::fmt::Display for DestructFull {3155	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3156		std::fmt::Display::fmt(self.syntax(), f)3157	}3158}3159impl std::fmt::Display for DestructSkip {3160	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3161		std::fmt::Display::fmt(self.syntax(), f)3162	}3163}3164impl std::fmt::Display for DestructArray {3165	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3166		std::fmt::Display::fmt(self.syntax(), f)3167	}3168}3169impl std::fmt::Display for DestructObject {3170	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3171		std::fmt::Display::fmt(self.syntax(), f)3172	}3173}3174impl std::fmt::Display for DestructObjectField {3175	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3176		std::fmt::Display::fmt(self.syntax(), f)3177	}3178}3179impl std::fmt::Display for DestructRest {3180	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3181		std::fmt::Display::fmt(self.syntax(), f)3182	}3183}3184impl std::fmt::Display for DestructArrayElement {3185	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3186		std::fmt::Display::fmt(self.syntax(), f)3187	}3188}