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

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::children(&self.syntax).next()18	}19}2021#[derive(Debug, Clone, PartialEq, Eq, Hash)]22pub struct Expr {23	pub(crate) syntax: SyntaxNode,24}25impl Expr {26	pub fn stmts(&self) -> AstChildren<Stmt> {27		support::children(&self.syntax)28	}29	pub fn expr_base(&self) -> Option<ExprBase> {30		support::children(&self.syntax).next()31	}32	pub fn suffixs(&self) -> AstChildren<Suffix> {33		support::children(&self.syntax)34	}35}3637#[derive(Debug, Clone, PartialEq, Eq, Hash)]38pub struct SuffixIndex {39	pub(crate) syntax: SyntaxNode,40}41impl SuffixIndex {42	pub fn question_mark_token(&self) -> Option<SyntaxToken> {43		support::token(&self.syntax, T![?])44	}45	pub fn dot_token(&self) -> Option<SyntaxToken> {46		support::token(&self.syntax, T![.])47	}48	pub fn index(&self) -> Option<Name> {49		support::children(&self.syntax).next()50	}51}5253#[derive(Debug, Clone, PartialEq, Eq, Hash)]54pub struct Name {55	pub(crate) syntax: SyntaxNode,56}57impl Name {58	pub fn ident_lit(&self) -> Option<SyntaxToken> {59		support::token(&self.syntax, IDENT)60	}61}6263#[derive(Debug, Clone, PartialEq, Eq, Hash)]64pub struct SuffixIndexExpr {65	pub(crate) syntax: SyntaxNode,66}67impl SuffixIndexExpr {68	pub fn question_mark_token(&self) -> Option<SyntaxToken> {69		support::token(&self.syntax, T![?])70	}71	pub fn dot_token(&self) -> Option<SyntaxToken> {72		support::token(&self.syntax, T![.])73	}74	pub fn l_brack_token(&self) -> Option<SyntaxToken> {75		support::token(&self.syntax, T!['['])76	}77	pub fn index(&self) -> Option<Expr> {78		support::children(&self.syntax).next()79	}80	pub fn r_brack_token(&self) -> Option<SyntaxToken> {81		support::token(&self.syntax, T![']'])82	}83}8485#[derive(Debug, Clone, PartialEq, Eq, Hash)]86pub struct SuffixSlice {87	pub(crate) syntax: SyntaxNode,88}89impl SuffixSlice {90	pub fn slice_desc(&self) -> Option<SliceDesc> {91		support::children(&self.syntax).next()92	}93}9495#[derive(Debug, Clone, PartialEq, Eq, Hash)]96pub struct SliceDesc {97	pub(crate) syntax: SyntaxNode,98}99impl SliceDesc {100	pub fn l_brack_token(&self) -> Option<SyntaxToken> {101		support::token(&self.syntax, T!['['])102	}103	pub fn from(&self) -> Option<Expr> {104		support::children(&self.syntax).next()105	}106	pub fn colon_token(&self) -> Option<SyntaxToken> {107		support::token(&self.syntax, T![:])108	}109	pub fn end(&self) -> Option<SliceDescEnd> {110		support::children(&self.syntax).next()111	}112	pub fn step(&self) -> Option<SliceDescStep> {113		support::children(&self.syntax).next()114	}115	pub fn r_brack_token(&self) -> Option<SyntaxToken> {116		support::token(&self.syntax, T![']'])117	}118}119120#[derive(Debug, Clone, PartialEq, Eq, Hash)]121pub struct SuffixApply {122	pub(crate) syntax: SyntaxNode,123}124impl SuffixApply {125	pub fn args_desc(&self) -> Option<ArgsDesc> {126		support::children(&self.syntax).next()127	}128	pub fn tailstrict_kw_token(&self) -> Option<SyntaxToken> {129		support::token(&self.syntax, T![tailstrict])130	}131}132133#[derive(Debug, Clone, PartialEq, Eq, Hash)]134pub struct ArgsDesc {135	pub(crate) syntax: SyntaxNode,136}137impl ArgsDesc {138	pub fn l_paren_token(&self) -> Option<SyntaxToken> {139		support::token(&self.syntax, T!['('])140	}141	pub fn args(&self) -> AstChildren<Arg> {142		support::children(&self.syntax)143	}144	pub fn r_paren_token(&self) -> Option<SyntaxToken> {145		support::token(&self.syntax, T![')'])146	}147}148149#[derive(Debug, Clone, PartialEq, Eq, Hash)]150pub struct StmtLocal {151	pub(crate) syntax: SyntaxNode,152}153impl StmtLocal {154	pub fn local_kw_token(&self) -> Option<SyntaxToken> {155		support::token(&self.syntax, T![local])156	}157	pub fn binds(&self) -> AstChildren<Bind> {158		support::children(&self.syntax)159	}160	pub fn semi_token(&self) -> Option<SyntaxToken> {161		support::token(&self.syntax, T![;])162	}163}164165#[derive(Debug, Clone, PartialEq, Eq, Hash)]166pub struct StmtAssert {167	pub(crate) syntax: SyntaxNode,168}169impl StmtAssert {170	pub fn assertion(&self) -> Option<Assertion> {171		support::children(&self.syntax).next()172	}173	pub fn semi_token(&self) -> Option<SyntaxToken> {174		support::token(&self.syntax, T![;])175	}176}177178#[derive(Debug, Clone, PartialEq, Eq, Hash)]179pub struct Assertion {180	pub(crate) syntax: SyntaxNode,181}182impl Assertion {183	pub fn assert_kw_token(&self) -> Option<SyntaxToken> {184		support::token(&self.syntax, T![assert])185	}186	pub fn condition(&self) -> Option<Expr> {187		support::children(&self.syntax).next()188	}189	pub fn colon_token(&self) -> Option<SyntaxToken> {190		support::token(&self.syntax, T![:])191	}192	pub fn message(&self) -> Option<Expr> {193		support::children(&self.syntax).nth(1usize)194	}195}196197#[derive(Debug, Clone, PartialEq, Eq, Hash)]198pub struct ExprBinary {199	pub(crate) syntax: SyntaxNode,200}201impl ExprBinary {202	pub fn lhs(&self) -> Option<Expr> {203		support::children(&self.syntax).next()204	}205	pub fn binary_operator(&self) -> Option<BinaryOperator> {206		support::token_child(&self.syntax)207	}208	pub fn rhs(&self) -> Option<Expr> {209		support::children(&self.syntax).nth(1usize)210	}211}212213#[derive(Debug, Clone, PartialEq, Eq, Hash)]214pub struct ExprUnary {215	pub(crate) syntax: SyntaxNode,216}217impl ExprUnary {218	pub fn unary_operator(&self) -> Option<UnaryOperator> {219		support::token_child(&self.syntax)220	}221	pub fn rhs(&self) -> Option<Expr> {222		support::children(&self.syntax).next()223	}224}225226#[derive(Debug, Clone, PartialEq, Eq, Hash)]227pub struct ExprObjExtend {228	pub(crate) syntax: SyntaxNode,229}230impl ExprObjExtend {231	pub fn expr(&self) -> Option<Expr> {232		support::children(&self.syntax).next()233	}234}235236#[derive(Debug, Clone, PartialEq, Eq, Hash)]237pub struct ExprParened {238	pub(crate) syntax: SyntaxNode,239}240impl ExprParened {241	pub fn l_paren_token(&self) -> Option<SyntaxToken> {242		support::token(&self.syntax, T!['('])243	}244	pub fn expr(&self) -> Option<Expr> {245		support::children(&self.syntax).next()246	}247	pub fn r_paren_token(&self) -> Option<SyntaxToken> {248		support::token(&self.syntax, T![')'])249	}250}251252#[derive(Debug, Clone, PartialEq, Eq, Hash)]253pub struct ExprLiteral {254	pub(crate) syntax: SyntaxNode,255}256impl ExprLiteral {257	pub fn literal(&self) -> Option<Literal> {258		support::token_child(&self.syntax)259	}260}261262#[derive(Debug, Clone, PartialEq, Eq, Hash)]263pub struct ExprString {264	pub(crate) syntax: SyntaxNode,265}266impl ExprString {267	pub fn text(&self) -> Option<Text> {268		support::token_child(&self.syntax)269	}270}271272#[derive(Debug, Clone, PartialEq, Eq, Hash)]273pub struct ExprNumber {274	pub(crate) syntax: SyntaxNode,275}276impl ExprNumber {277	pub fn number(&self) -> Option<Number> {278		support::token_child(&self.syntax)279	}280}281282#[derive(Debug, Clone, PartialEq, Eq, Hash)]283pub struct ExprArray {284	pub(crate) syntax: SyntaxNode,285}286impl ExprArray {287	pub fn l_brack_token(&self) -> Option<SyntaxToken> {288		support::token(&self.syntax, T!['['])289	}290	pub fn exprs(&self) -> AstChildren<Expr> {291		support::children(&self.syntax)292	}293	pub fn r_brack_token(&self) -> Option<SyntaxToken> {294		support::token(&self.syntax, T![']'])295	}296}297298#[derive(Debug, Clone, PartialEq, Eq, Hash)]299pub struct ExprObject {300	pub(crate) syntax: SyntaxNode,301}302impl ExprObject {303	pub fn obj_body(&self) -> Option<ObjBody> {304		support::children(&self.syntax).next()305	}306}307308#[derive(Debug, Clone, PartialEq, Eq, Hash)]309pub struct ExprArrayComp {310	pub(crate) syntax: SyntaxNode,311}312impl ExprArrayComp {313	pub fn l_brack_token(&self) -> Option<SyntaxToken> {314		support::token(&self.syntax, T!['['])315	}316	pub fn expr(&self) -> Option<Expr> {317		support::children(&self.syntax).next()318	}319	pub fn comma_token(&self) -> Option<SyntaxToken> {320		support::token(&self.syntax, T![,])321	}322	pub fn comp_specs(&self) -> AstChildren<CompSpec> {323		support::children(&self.syntax)324	}325	pub fn r_brack_token(&self) -> Option<SyntaxToken> {326		support::token(&self.syntax, T![']'])327	}328}329330#[derive(Debug, Clone, PartialEq, Eq, Hash)]331pub struct ExprImport {332	pub(crate) syntax: SyntaxNode,333}334impl ExprImport {335	pub fn import_kind(&self) -> Option<ImportKind> {336		support::token_child(&self.syntax)337	}338	pub fn text(&self) -> Option<Text> {339		support::token_child(&self.syntax)340	}341}342343#[derive(Debug, Clone, PartialEq, Eq, Hash)]344pub struct ExprVar {345	pub(crate) syntax: SyntaxNode,346}347impl ExprVar {348	pub fn name(&self) -> Option<Name> {349		support::children(&self.syntax).next()350	}351}352353#[derive(Debug, Clone, PartialEq, Eq, Hash)]354pub struct ExprIfThenElse {355	pub(crate) syntax: SyntaxNode,356}357impl ExprIfThenElse {358	pub fn if_kw_token(&self) -> Option<SyntaxToken> {359		support::token(&self.syntax, T![if])360	}361	pub fn cond(&self) -> Option<Expr> {362		support::children(&self.syntax).next()363	}364	pub fn then_kw_token(&self) -> Option<SyntaxToken> {365		support::token(&self.syntax, T![then])366	}367	pub fn then(&self) -> Option<TrueExpr> {368		support::children(&self.syntax).next()369	}370	pub fn else_kw_token(&self) -> Option<SyntaxToken> {371		support::token(&self.syntax, T![else])372	}373	pub fn else_(&self) -> Option<FalseExpr> {374		support::children(&self.syntax).next()375	}376}377378#[derive(Debug, Clone, PartialEq, Eq, Hash)]379pub struct TrueExpr {380	pub(crate) syntax: SyntaxNode,381}382impl TrueExpr {383	pub fn expr(&self) -> Option<Expr> {384		support::children(&self.syntax).next()385	}386}387388#[derive(Debug, Clone, PartialEq, Eq, Hash)]389pub struct FalseExpr {390	pub(crate) syntax: SyntaxNode,391}392impl FalseExpr {393	pub fn expr(&self) -> Option<Expr> {394		support::children(&self.syntax).next()395	}396}397398#[derive(Debug, Clone, PartialEq, Eq, Hash)]399pub struct ExprFunction {400	pub(crate) syntax: SyntaxNode,401}402impl ExprFunction {403	pub fn function_kw_token(&self) -> Option<SyntaxToken> {404		support::token(&self.syntax, T![function])405	}406	pub fn l_paren_token(&self) -> Option<SyntaxToken> {407		support::token(&self.syntax, T!['('])408	}409	pub fn params_desc(&self) -> Option<ParamsDesc> {410		support::children(&self.syntax).next()411	}412	pub fn r_paren_token(&self) -> Option<SyntaxToken> {413		support::token(&self.syntax, T![')'])414	}415	pub fn expr(&self) -> Option<Expr> {416		support::children(&self.syntax).next()417	}418}419420#[derive(Debug, Clone, PartialEq, Eq, Hash)]421pub struct ParamsDesc {422	pub(crate) syntax: SyntaxNode,423}424impl ParamsDesc {425	pub fn l_paren_token(&self) -> Option<SyntaxToken> {426		support::token(&self.syntax, T!['('])427	}428	pub fn params(&self) -> AstChildren<Param> {429		support::children(&self.syntax)430	}431	pub fn r_paren_token(&self) -> Option<SyntaxToken> {432		support::token(&self.syntax, T![')'])433	}434}435436#[derive(Debug, Clone, PartialEq, Eq, Hash)]437pub struct ExprError {438	pub(crate) syntax: SyntaxNode,439}440impl ExprError {441	pub fn error_kw_token(&self) -> Option<SyntaxToken> {442		support::token(&self.syntax, T![error])443	}444	pub fn expr(&self) -> Option<Expr> {445		support::children(&self.syntax).next()446	}447}448449#[derive(Debug, Clone, PartialEq, Eq, Hash)]450pub struct SliceDescEnd {451	pub(crate) syntax: SyntaxNode,452}453impl SliceDescEnd {454	pub fn expr(&self) -> Option<Expr> {455		support::children(&self.syntax).next()456	}457}458459#[derive(Debug, Clone, PartialEq, Eq, Hash)]460pub struct SliceDescStep {461	pub(crate) syntax: SyntaxNode,462}463impl SliceDescStep {464	pub fn expr(&self) -> Option<Expr> {465		support::children(&self.syntax).next()466	}467}468469#[derive(Debug, Clone, PartialEq, Eq, Hash)]470pub struct Arg {471	pub(crate) syntax: SyntaxNode,472}473impl Arg {474	pub fn name(&self) -> Option<Name> {475		support::children(&self.syntax).next()476	}477	pub fn assign_token(&self) -> Option<SyntaxToken> {478		support::token(&self.syntax, T![=])479	}480	pub fn expr(&self) -> Option<Expr> {481		support::children(&self.syntax).next()482	}483}484485#[derive(Debug, Clone, PartialEq, Eq, Hash)]486pub struct ObjBodyComp {487	pub(crate) syntax: SyntaxNode,488}489impl ObjBodyComp {490	pub fn l_brace_token(&self) -> Option<SyntaxToken> {491		support::token(&self.syntax, T!['{'])492	}493	pub fn member_comps(&self) -> AstChildren<MemberComp> {494		support::children(&self.syntax)495	}496	pub fn comp_specs(&self) -> AstChildren<CompSpec> {497		support::children(&self.syntax)498	}499	pub fn r_brace_token(&self) -> Option<SyntaxToken> {500		support::token(&self.syntax, T!['}'])501	}502}503504#[derive(Debug, Clone, PartialEq, Eq, Hash)]505pub struct ObjBodyMemberList {506	pub(crate) syntax: SyntaxNode,507}508impl ObjBodyMemberList {509	pub fn l_brace_token(&self) -> Option<SyntaxToken> {510		support::token(&self.syntax, T!['{'])511	}512	pub fn members(&self) -> AstChildren<Member> {513		support::children(&self.syntax)514	}515	pub fn r_brace_token(&self) -> Option<SyntaxToken> {516		support::token(&self.syntax, T!['}'])517	}518}519520#[derive(Debug, Clone, PartialEq, Eq, Hash)]521pub struct MemberBindStmt {522	pub(crate) syntax: SyntaxNode,523}524impl MemberBindStmt {525	pub fn obj_local(&self) -> Option<ObjLocal> {526		support::children(&self.syntax).next()527	}528}529530#[derive(Debug, Clone, PartialEq, Eq, Hash)]531pub struct ObjLocal {532	pub(crate) syntax: SyntaxNode,533}534impl ObjLocal {535	pub fn local_kw_token(&self) -> Option<SyntaxToken> {536		support::token(&self.syntax, T![local])537	}538	pub fn bind(&self) -> Option<Bind> {539		support::children(&self.syntax).next()540	}541}542543#[derive(Debug, Clone, PartialEq, Eq, Hash)]544pub struct MemberAssertStmt {545	pub(crate) syntax: SyntaxNode,546}547impl MemberAssertStmt {548	pub fn assertion(&self) -> Option<Assertion> {549		support::children(&self.syntax).next()550	}551}552553#[derive(Debug, Clone, PartialEq, Eq, Hash)]554pub struct MemberFieldNormal {555	pub(crate) syntax: SyntaxNode,556}557impl MemberFieldNormal {558	pub fn field_name(&self) -> Option<FieldName> {559		support::children(&self.syntax).next()560	}561	pub fn plus_token(&self) -> Option<SyntaxToken> {562		support::token(&self.syntax, T![+])563	}564	pub fn visibility(&self) -> Option<Visibility> {565		support::token_child(&self.syntax)566	}567	pub fn expr(&self) -> Option<Expr> {568		support::children(&self.syntax).next()569	}570}571572#[derive(Debug, Clone, PartialEq, Eq, Hash)]573pub struct MemberFieldMethod {574	pub(crate) syntax: SyntaxNode,575}576impl MemberFieldMethod {577	pub fn field_name(&self) -> Option<FieldName> {578		support::children(&self.syntax).next()579	}580	pub fn params_desc(&self) -> Option<ParamsDesc> {581		support::children(&self.syntax).next()582	}583	pub fn visibility(&self) -> Option<Visibility> {584		support::token_child(&self.syntax)585	}586	pub fn expr(&self) -> Option<Expr> {587		support::children(&self.syntax).next()588	}589}590591#[derive(Debug, Clone, PartialEq, Eq, Hash)]592pub struct FieldNameFixed {593	pub(crate) syntax: SyntaxNode,594}595impl FieldNameFixed {596	pub fn id(&self) -> Option<Name> {597		support::children(&self.syntax).next()598	}599	pub fn text(&self) -> Option<Text> {600		support::token_child(&self.syntax)601	}602}603604#[derive(Debug, Clone, PartialEq, Eq, Hash)]605pub struct FieldNameDynamic {606	pub(crate) syntax: SyntaxNode,607}608impl FieldNameDynamic {609	pub fn l_brack_token(&self) -> Option<SyntaxToken> {610		support::token(&self.syntax, T!['['])611	}612	pub fn expr(&self) -> Option<Expr> {613		support::children(&self.syntax).next()614	}615	pub fn r_brack_token(&self) -> Option<SyntaxToken> {616		support::token(&self.syntax, T![']'])617	}618}619620#[derive(Debug, Clone, PartialEq, Eq, Hash)]621pub struct ForSpec {622	pub(crate) syntax: SyntaxNode,623}624impl ForSpec {625	pub fn for_kw_token(&self) -> Option<SyntaxToken> {626		support::token(&self.syntax, T![for])627	}628	pub fn bind(&self) -> Option<Destruct> {629		support::children(&self.syntax).next()630	}631	pub fn in_kw_token(&self) -> Option<SyntaxToken> {632		support::token(&self.syntax, T![in])633	}634	pub fn expr(&self) -> Option<Expr> {635		support::children(&self.syntax).next()636	}637}638639#[derive(Debug, Clone, PartialEq, Eq, Hash)]640pub struct IfSpec {641	pub(crate) syntax: SyntaxNode,642}643impl IfSpec {644	pub fn if_kw_token(&self) -> Option<SyntaxToken> {645		support::token(&self.syntax, T![if])646	}647	pub fn expr(&self) -> Option<Expr> {648		support::children(&self.syntax).next()649	}650}651652#[derive(Debug, Clone, PartialEq, Eq, Hash)]653pub struct BindDestruct {654	pub(crate) syntax: SyntaxNode,655}656impl BindDestruct {657	pub fn into(&self) -> Option<Destruct> {658		support::children(&self.syntax).next()659	}660	pub fn assign_token(&self) -> Option<SyntaxToken> {661		support::token(&self.syntax, T![=])662	}663	pub fn value(&self) -> Option<Expr> {664		support::children(&self.syntax).next()665	}666}667668#[derive(Debug, Clone, PartialEq, Eq, Hash)]669pub struct BindFunction {670	pub(crate) syntax: SyntaxNode,671}672impl BindFunction {673	pub fn name(&self) -> Option<Name> {674		support::children(&self.syntax).next()675	}676	pub fn params(&self) -> Option<ParamsDesc> {677		support::children(&self.syntax).next()678	}679	pub fn assign_token(&self) -> Option<SyntaxToken> {680		support::token(&self.syntax, T![=])681	}682	pub fn value(&self) -> Option<Expr> {683		support::children(&self.syntax).next()684	}685}686687#[derive(Debug, Clone, PartialEq, Eq, Hash)]688pub struct Param {689	pub(crate) syntax: SyntaxNode,690}691impl Param {692	pub fn destruct(&self) -> Option<Destruct> {693		support::children(&self.syntax).next()694	}695	pub fn assign_token(&self) -> Option<SyntaxToken> {696		support::token(&self.syntax, T![=])697	}698	pub fn expr(&self) -> Option<Expr> {699		support::children(&self.syntax).next()700	}701}702703#[derive(Debug, Clone, PartialEq, Eq, Hash)]704pub struct DestructFull {705	pub(crate) syntax: SyntaxNode,706}707impl DestructFull {708	pub fn name(&self) -> Option<Name> {709		support::children(&self.syntax).next()710	}711}712713#[derive(Debug, Clone, PartialEq, Eq, Hash)]714pub struct DestructSkip {715	pub(crate) syntax: SyntaxNode,716}717impl DestructSkip {718	pub fn question_mark_token(&self) -> Option<SyntaxToken> {719		support::token(&self.syntax, T![?])720	}721}722723#[derive(Debug, Clone, PartialEq, Eq, Hash)]724pub struct DestructArray {725	pub(crate) syntax: SyntaxNode,726}727impl DestructArray {728	pub fn l_brack_token(&self) -> Option<SyntaxToken> {729		support::token(&self.syntax, T!['['])730	}731	pub fn destruct_array_parts(&self) -> AstChildren<DestructArrayPart> {732		support::children(&self.syntax)733	}734	pub fn r_brack_token(&self) -> Option<SyntaxToken> {735		support::token(&self.syntax, T![']'])736	}737}738739#[derive(Debug, Clone, PartialEq, Eq, Hash)]740pub struct DestructObject {741	pub(crate) syntax: SyntaxNode,742}743impl DestructObject {744	pub fn l_brace_token(&self) -> Option<SyntaxToken> {745		support::token(&self.syntax, T!['{'])746	}747	pub fn destruct_object_fields(&self) -> AstChildren<DestructObjectField> {748		support::children(&self.syntax)749	}750	pub fn destruct_rest(&self) -> Option<DestructRest> {751		support::children(&self.syntax).next()752	}753	pub fn comma_token(&self) -> Option<SyntaxToken> {754		support::token(&self.syntax, T![,])755	}756	pub fn r_brace_token(&self) -> Option<SyntaxToken> {757		support::token(&self.syntax, T!['}'])758	}759}760761#[derive(Debug, Clone, PartialEq, Eq, Hash)]762pub struct DestructObjectField {763	pub(crate) syntax: SyntaxNode,764}765impl DestructObjectField {766	pub fn field(&self) -> Option<Name> {767		support::children(&self.syntax).next()768	}769	pub fn colon_token(&self) -> Option<SyntaxToken> {770		support::token(&self.syntax, T![:])771	}772	pub fn destruct(&self) -> Option<Destruct> {773		support::children(&self.syntax).next()774	}775	pub fn assign_token(&self) -> Option<SyntaxToken> {776		support::token(&self.syntax, T![=])777	}778	pub fn expr(&self) -> Option<Expr> {779		support::children(&self.syntax).next()780	}781}782783#[derive(Debug, Clone, PartialEq, Eq, Hash)]784pub struct DestructRest {785	pub(crate) syntax: SyntaxNode,786}787impl DestructRest {788	pub fn dotdotdot_token(&self) -> Option<SyntaxToken> {789		support::token(&self.syntax, T![...])790	}791	pub fn into(&self) -> Option<Name> {792		support::children(&self.syntax).next()793	}794}795796#[derive(Debug, Clone, PartialEq, Eq, Hash)]797pub struct DestructArrayElement {798	pub(crate) syntax: SyntaxNode,799}800impl DestructArrayElement {801	pub fn destruct(&self) -> Option<Destruct> {802		support::children(&self.syntax).next()803	}804}805806#[derive(Debug, Clone, PartialEq, Eq, Hash)]807pub enum Suffix {808	SuffixIndex(SuffixIndex),809	SuffixIndexExpr(SuffixIndexExpr),810	SuffixSlice(SuffixSlice),811	SuffixApply(SuffixApply),812}813814#[derive(Debug, Clone, PartialEq, Eq, Hash)]815pub enum Bind {816	BindDestruct(BindDestruct),817	BindFunction(BindFunction),818}819820#[derive(Debug, Clone, PartialEq, Eq, Hash)]821pub enum Stmt {822	StmtLocal(StmtLocal),823	StmtAssert(StmtAssert),824}825826#[derive(Debug, Clone, PartialEq, Eq, Hash)]827pub enum ObjBody {828	ObjBodyComp(ObjBodyComp),829	ObjBodyMemberList(ObjBodyMemberList),830}831832#[derive(Debug, Clone, PartialEq, Eq, Hash)]833pub enum CompSpec {834	ForSpec(ForSpec),835	IfSpec(IfSpec),836}837838#[derive(Debug, Clone, PartialEq, Eq, Hash)]839pub enum ExprBase {840	ExprBinary(ExprBinary),841	ExprUnary(ExprUnary),842	ExprObjExtend(ExprObjExtend),843	ExprParened(ExprParened),844	ExprString(ExprString),845	ExprNumber(ExprNumber),846	ExprLiteral(ExprLiteral),847	ExprArray(ExprArray),848	ExprObject(ExprObject),849	ExprArrayComp(ExprArrayComp),850	ExprImport(ExprImport),851	ExprVar(ExprVar),852	ExprIfThenElse(ExprIfThenElse),853	ExprFunction(ExprFunction),854	ExprError(ExprError),855}856857#[derive(Debug, Clone, PartialEq, Eq, Hash)]858pub enum MemberComp {859	MemberBindStmt(MemberBindStmt),860	MemberFieldNormal(MemberFieldNormal),861	MemberFieldMethod(MemberFieldMethod),862}863864#[derive(Debug, Clone, PartialEq, Eq, Hash)]865pub enum Member {866	MemberBindStmt(MemberBindStmt),867	MemberAssertStmt(MemberAssertStmt),868	MemberFieldNormal(MemberFieldNormal),869	MemberFieldMethod(MemberFieldMethod),870}871872#[derive(Debug, Clone, PartialEq, Eq, Hash)]873pub enum FieldName {874	FieldNameFixed(FieldNameFixed),875	FieldNameDynamic(FieldNameDynamic),876}877878#[derive(Debug, Clone, PartialEq, Eq, Hash)]879pub enum Destruct {880	DestructFull(DestructFull),881	DestructSkip(DestructSkip),882	DestructArray(DestructArray),883	DestructObject(DestructObject),884}885886#[derive(Debug, Clone, PartialEq, Eq, Hash)]887pub enum DestructArrayPart {888	DestructArrayElement(DestructArrayElement),889	DestructRest(DestructRest),890}891892#[derive(Debug, Clone, PartialEq, Eq, Hash)]893pub struct BinaryOperator {894	syntax: SyntaxToken,895	kind: BinaryOperatorKind,896}897898#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]899pub enum BinaryOperatorKind {900	Or,901	NullCoaelse,902	And,903	BitOr,904	BitXor,905	BitAnd,906	Eq,907	Ne,908	Lt,909	Gt,910	Le,911	Ge,912	InKw,913	Lhs,914	Rhs,915	Plus,916	Minus,917	Mul,918	Div,919	Modulo,920	MetaObjectApply,921	ErrorNoOperator,922}923924#[derive(Debug, Clone, PartialEq, Eq, Hash)]925pub struct UnaryOperator {926	syntax: SyntaxToken,927	kind: UnaryOperatorKind,928}929930#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]931pub enum UnaryOperatorKind {932	Minus,933	Not,934	BitNot,935}936937#[derive(Debug, Clone, PartialEq, Eq, Hash)]938pub struct Literal {939	syntax: SyntaxToken,940	kind: LiteralKind,941}942943#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]944pub enum LiteralKind {945	NullKw,946	TrueKw,947	FalseKw,948	SelfKw,949	Dollar,950	SuperKw,951}952953#[derive(Debug, Clone, PartialEq, Eq, Hash)]954pub struct Text {955	syntax: SyntaxToken,956	kind: TextKind,957}958959#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]960pub enum TextKind {961	StringDouble,962	ErrorStringDoubleUnterminated,963	StringSingle,964	ErrorStringSingleUnterminated,965	StringDoubleVerbatim,966	ErrorStringDoubleVerbatimUnterminated,967	StringSingleVerbatim,968	ErrorStringSingleVerbatimUnterminated,969	ErrorStringVerbatimMissingQuotes,970	StringBlock,971	ErrorStringBlockUnexpectedEnd,972	ErrorStringBlockMissingNewLine,973	ErrorStringBlockMissingTermination,974	ErrorStringBlockMissingIndent,975}976977#[derive(Debug, Clone, PartialEq, Eq, Hash)]978pub struct Number {979	syntax: SyntaxToken,980	kind: NumberKind,981}982983#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]984pub enum NumberKind {985	Float,986	ErrorFloatJunkAfterPoint,987	ErrorFloatJunkAfterExponent,988	ErrorFloatJunkAfterExponentSign,989}990991#[derive(Debug, Clone, PartialEq, Eq, Hash)]992pub struct ImportKind {993	syntax: SyntaxToken,994	kind: ImportKindKind,995}996997#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]998pub enum ImportKindKind {999	ImportstrKw,1000	ImportbinKw,1001	ImportKw,1002}10031004#[derive(Debug, Clone, PartialEq, Eq, Hash)]1005pub struct Visibility {1006	syntax: SyntaxToken,1007	kind: VisibilityKind,1008}10091010#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]1011pub enum VisibilityKind {1012	Coloncoloncolon,1013	Coloncolon,1014	Colon,1015}10161017#[derive(Debug, Clone, PartialEq, Eq, Hash)]1018pub struct Trivia {1019	syntax: SyntaxToken,1020	kind: TriviaKind,1021}10221023#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]1024pub enum TriviaKind {1025	Whitespace,1026	MultiLineComment,1027	ErrorCommentTooShort,1028	ErrorCommentUnterminated,1029	SingleLineHashComment,1030	SingleLineSlashComment,1031}10321033#[derive(Debug, Clone, PartialEq, Eq, Hash)]1034pub struct CustomError {1035	syntax: SyntaxToken,1036	kind: CustomErrorKind,1037}10381039#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]1040pub enum CustomErrorKind {1041	ErrorMissingToken,1042	ErrorUnexpectedToken,1043	ErrorCustom,1044}1045impl AstNode for SourceFile {1046	fn can_cast(kind: SyntaxKind) -> bool {1047		kind == SOURCE_FILE1048	}1049	fn cast(syntax: SyntaxNode) -> Option<Self> {1050		if Self::can_cast(syntax.kind()) {1051			Some(Self { syntax })1052		} else {1053			None1054		}1055	}1056	fn syntax(&self) -> &SyntaxNode {1057		&self.syntax1058	}1059}1060impl AstNode for Expr {1061	fn can_cast(kind: SyntaxKind) -> bool {1062		kind == EXPR1063	}1064	fn cast(syntax: SyntaxNode) -> Option<Self> {1065		if Self::can_cast(syntax.kind()) {1066			Some(Self { syntax })1067		} else {1068			None1069		}1070	}1071	fn syntax(&self) -> &SyntaxNode {1072		&self.syntax1073	}1074}1075impl AstNode for SuffixIndex {1076	fn can_cast(kind: SyntaxKind) -> bool {1077		kind == SUFFIX_INDEX1078	}1079	fn cast(syntax: SyntaxNode) -> Option<Self> {1080		if Self::can_cast(syntax.kind()) {1081			Some(Self { syntax })1082		} else {1083			None1084		}1085	}1086	fn syntax(&self) -> &SyntaxNode {1087		&self.syntax1088	}1089}1090impl AstNode for Name {1091	fn can_cast(kind: SyntaxKind) -> bool {1092		kind == NAME1093	}1094	fn cast(syntax: SyntaxNode) -> Option<Self> {1095		if Self::can_cast(syntax.kind()) {1096			Some(Self { syntax })1097		} else {1098			None1099		}1100	}1101	fn syntax(&self) -> &SyntaxNode {1102		&self.syntax1103	}1104}1105impl AstNode for SuffixIndexExpr {1106	fn can_cast(kind: SyntaxKind) -> bool {1107		kind == SUFFIX_INDEX_EXPR1108	}1109	fn cast(syntax: SyntaxNode) -> Option<Self> {1110		if Self::can_cast(syntax.kind()) {1111			Some(Self { syntax })1112		} else {1113			None1114		}1115	}1116	fn syntax(&self) -> &SyntaxNode {1117		&self.syntax1118	}1119}1120impl AstNode for SuffixSlice {1121	fn can_cast(kind: SyntaxKind) -> bool {1122		kind == SUFFIX_SLICE1123	}1124	fn cast(syntax: SyntaxNode) -> Option<Self> {1125		if Self::can_cast(syntax.kind()) {1126			Some(Self { syntax })1127		} else {1128			None1129		}1130	}1131	fn syntax(&self) -> &SyntaxNode {1132		&self.syntax1133	}1134}1135impl AstNode for SliceDesc {1136	fn can_cast(kind: SyntaxKind) -> bool {1137		kind == SLICE_DESC1138	}1139	fn cast(syntax: SyntaxNode) -> Option<Self> {1140		if Self::can_cast(syntax.kind()) {1141			Some(Self { syntax })1142		} else {1143			None1144		}1145	}1146	fn syntax(&self) -> &SyntaxNode {1147		&self.syntax1148	}1149}1150impl AstNode for SuffixApply {1151	fn can_cast(kind: SyntaxKind) -> bool {1152		kind == SUFFIX_APPLY1153	}1154	fn cast(syntax: SyntaxNode) -> Option<Self> {1155		if Self::can_cast(syntax.kind()) {1156			Some(Self { syntax })1157		} else {1158			None1159		}1160	}1161	fn syntax(&self) -> &SyntaxNode {1162		&self.syntax1163	}1164}1165impl AstNode for ArgsDesc {1166	fn can_cast(kind: SyntaxKind) -> bool {1167		kind == ARGS_DESC1168	}1169	fn cast(syntax: SyntaxNode) -> Option<Self> {1170		if Self::can_cast(syntax.kind()) {1171			Some(Self { syntax })1172		} else {1173			None1174		}1175	}1176	fn syntax(&self) -> &SyntaxNode {1177		&self.syntax1178	}1179}1180impl AstNode for StmtLocal {1181	fn can_cast(kind: SyntaxKind) -> bool {1182		kind == STMT_LOCAL1183	}1184	fn cast(syntax: SyntaxNode) -> Option<Self> {1185		if Self::can_cast(syntax.kind()) {1186			Some(Self { syntax })1187		} else {1188			None1189		}1190	}1191	fn syntax(&self) -> &SyntaxNode {1192		&self.syntax1193	}1194}1195impl AstNode for StmtAssert {1196	fn can_cast(kind: SyntaxKind) -> bool {1197		kind == STMT_ASSERT1198	}1199	fn cast(syntax: SyntaxNode) -> Option<Self> {1200		if Self::can_cast(syntax.kind()) {1201			Some(Self { syntax })1202		} else {1203			None1204		}1205	}1206	fn syntax(&self) -> &SyntaxNode {1207		&self.syntax1208	}1209}1210impl AstNode for Assertion {1211	fn can_cast(kind: SyntaxKind) -> bool {1212		kind == ASSERTION1213	}1214	fn cast(syntax: SyntaxNode) -> Option<Self> {1215		if Self::can_cast(syntax.kind()) {1216			Some(Self { syntax })1217		} else {1218			None1219		}1220	}1221	fn syntax(&self) -> &SyntaxNode {1222		&self.syntax1223	}1224}1225impl AstNode for ExprBinary {1226	fn can_cast(kind: SyntaxKind) -> bool {1227		kind == EXPR_BINARY1228	}1229	fn cast(syntax: SyntaxNode) -> Option<Self> {1230		if Self::can_cast(syntax.kind()) {1231			Some(Self { syntax })1232		} else {1233			None1234		}1235	}1236	fn syntax(&self) -> &SyntaxNode {1237		&self.syntax1238	}1239}1240impl AstNode for ExprUnary {1241	fn can_cast(kind: SyntaxKind) -> bool {1242		kind == EXPR_UNARY1243	}1244	fn cast(syntax: SyntaxNode) -> Option<Self> {1245		if Self::can_cast(syntax.kind()) {1246			Some(Self { syntax })1247		} else {1248			None1249		}1250	}1251	fn syntax(&self) -> &SyntaxNode {1252		&self.syntax1253	}1254}1255impl AstNode for ExprObjExtend {1256	fn can_cast(kind: SyntaxKind) -> bool {1257		kind == EXPR_OBJ_EXTEND1258	}1259	fn cast(syntax: SyntaxNode) -> Option<Self> {1260		if Self::can_cast(syntax.kind()) {1261			Some(Self { syntax })1262		} else {1263			None1264		}1265	}1266	fn syntax(&self) -> &SyntaxNode {1267		&self.syntax1268	}1269}1270impl AstNode for ExprParened {1271	fn can_cast(kind: SyntaxKind) -> bool {1272		kind == EXPR_PARENED1273	}1274	fn cast(syntax: SyntaxNode) -> Option<Self> {1275		if Self::can_cast(syntax.kind()) {1276			Some(Self { syntax })1277		} else {1278			None1279		}1280	}1281	fn syntax(&self) -> &SyntaxNode {1282		&self.syntax1283	}1284}1285impl AstNode for ExprLiteral {1286	fn can_cast(kind: SyntaxKind) -> bool {1287		kind == EXPR_LITERAL1288	}1289	fn cast(syntax: SyntaxNode) -> Option<Self> {1290		if Self::can_cast(syntax.kind()) {1291			Some(Self { syntax })1292		} else {1293			None1294		}1295	}1296	fn syntax(&self) -> &SyntaxNode {1297		&self.syntax1298	}1299}1300impl AstNode for ExprString {1301	fn can_cast(kind: SyntaxKind) -> bool {1302		kind == EXPR_STRING1303	}1304	fn cast(syntax: SyntaxNode) -> Option<Self> {1305		if Self::can_cast(syntax.kind()) {1306			Some(Self { syntax })1307		} else {1308			None1309		}1310	}1311	fn syntax(&self) -> &SyntaxNode {1312		&self.syntax1313	}1314}1315impl AstNode for ExprNumber {1316	fn can_cast(kind: SyntaxKind) -> bool {1317		kind == EXPR_NUMBER1318	}1319	fn cast(syntax: SyntaxNode) -> Option<Self> {1320		if Self::can_cast(syntax.kind()) {1321			Some(Self { syntax })1322		} else {1323			None1324		}1325	}1326	fn syntax(&self) -> &SyntaxNode {1327		&self.syntax1328	}1329}1330impl AstNode for ExprArray {1331	fn can_cast(kind: SyntaxKind) -> bool {1332		kind == EXPR_ARRAY1333	}1334	fn cast(syntax: SyntaxNode) -> Option<Self> {1335		if Self::can_cast(syntax.kind()) {1336			Some(Self { syntax })1337		} else {1338			None1339		}1340	}1341	fn syntax(&self) -> &SyntaxNode {1342		&self.syntax1343	}1344}1345impl AstNode for ExprObject {1346	fn can_cast(kind: SyntaxKind) -> bool {1347		kind == EXPR_OBJECT1348	}1349	fn cast(syntax: SyntaxNode) -> Option<Self> {1350		if Self::can_cast(syntax.kind()) {1351			Some(Self { syntax })1352		} else {1353			None1354		}1355	}1356	fn syntax(&self) -> &SyntaxNode {1357		&self.syntax1358	}1359}1360impl AstNode for ExprArrayComp {1361	fn can_cast(kind: SyntaxKind) -> bool {1362		kind == EXPR_ARRAY_COMP1363	}1364	fn cast(syntax: SyntaxNode) -> Option<Self> {1365		if Self::can_cast(syntax.kind()) {1366			Some(Self { syntax })1367		} else {1368			None1369		}1370	}1371	fn syntax(&self) -> &SyntaxNode {1372		&self.syntax1373	}1374}1375impl AstNode for ExprImport {1376	fn can_cast(kind: SyntaxKind) -> bool {1377		kind == EXPR_IMPORT1378	}1379	fn cast(syntax: SyntaxNode) -> Option<Self> {1380		if Self::can_cast(syntax.kind()) {1381			Some(Self { syntax })1382		} else {1383			None1384		}1385	}1386	fn syntax(&self) -> &SyntaxNode {1387		&self.syntax1388	}1389}1390impl AstNode for ExprVar {1391	fn can_cast(kind: SyntaxKind) -> bool {1392		kind == EXPR_VAR1393	}1394	fn cast(syntax: SyntaxNode) -> Option<Self> {1395		if Self::can_cast(syntax.kind()) {1396			Some(Self { syntax })1397		} else {1398			None1399		}1400	}1401	fn syntax(&self) -> &SyntaxNode {1402		&self.syntax1403	}1404}1405impl AstNode for ExprIfThenElse {1406	fn can_cast(kind: SyntaxKind) -> bool {1407		kind == EXPR_IF_THEN_ELSE1408	}1409	fn cast(syntax: SyntaxNode) -> Option<Self> {1410		if Self::can_cast(syntax.kind()) {1411			Some(Self { syntax })1412		} else {1413			None1414		}1415	}1416	fn syntax(&self) -> &SyntaxNode {1417		&self.syntax1418	}1419}1420impl AstNode for TrueExpr {1421	fn can_cast(kind: SyntaxKind) -> bool {1422		kind == TRUE_EXPR1423	}1424	fn cast(syntax: SyntaxNode) -> Option<Self> {1425		if Self::can_cast(syntax.kind()) {1426			Some(Self { syntax })1427		} else {1428			None1429		}1430	}1431	fn syntax(&self) -> &SyntaxNode {1432		&self.syntax1433	}1434}1435impl AstNode for FalseExpr {1436	fn can_cast(kind: SyntaxKind) -> bool {1437		kind == FALSE_EXPR1438	}1439	fn cast(syntax: SyntaxNode) -> Option<Self> {1440		if Self::can_cast(syntax.kind()) {1441			Some(Self { syntax })1442		} else {1443			None1444		}1445	}1446	fn syntax(&self) -> &SyntaxNode {1447		&self.syntax1448	}1449}1450impl AstNode for ExprFunction {1451	fn can_cast(kind: SyntaxKind) -> bool {1452		kind == EXPR_FUNCTION1453	}1454	fn cast(syntax: SyntaxNode) -> Option<Self> {1455		if Self::can_cast(syntax.kind()) {1456			Some(Self { syntax })1457		} else {1458			None1459		}1460	}1461	fn syntax(&self) -> &SyntaxNode {1462		&self.syntax1463	}1464}1465impl AstNode for ParamsDesc {1466	fn can_cast(kind: SyntaxKind) -> bool {1467		kind == PARAMS_DESC1468	}1469	fn cast(syntax: SyntaxNode) -> Option<Self> {1470		if Self::can_cast(syntax.kind()) {1471			Some(Self { syntax })1472		} else {1473			None1474		}1475	}1476	fn syntax(&self) -> &SyntaxNode {1477		&self.syntax1478	}1479}1480impl AstNode for ExprError {1481	fn can_cast(kind: SyntaxKind) -> bool {1482		kind == EXPR_ERROR1483	}1484	fn cast(syntax: SyntaxNode) -> Option<Self> {1485		if Self::can_cast(syntax.kind()) {1486			Some(Self { syntax })1487		} else {1488			None1489		}1490	}1491	fn syntax(&self) -> &SyntaxNode {1492		&self.syntax1493	}1494}1495impl AstNode for SliceDescEnd {1496	fn can_cast(kind: SyntaxKind) -> bool {1497		kind == SLICE_DESC_END1498	}1499	fn cast(syntax: SyntaxNode) -> Option<Self> {1500		if Self::can_cast(syntax.kind()) {1501			Some(Self { syntax })1502		} else {1503			None1504		}1505	}1506	fn syntax(&self) -> &SyntaxNode {1507		&self.syntax1508	}1509}1510impl AstNode for SliceDescStep {1511	fn can_cast(kind: SyntaxKind) -> bool {1512		kind == SLICE_DESC_STEP1513	}1514	fn cast(syntax: SyntaxNode) -> Option<Self> {1515		if Self::can_cast(syntax.kind()) {1516			Some(Self { syntax })1517		} else {1518			None1519		}1520	}1521	fn syntax(&self) -> &SyntaxNode {1522		&self.syntax1523	}1524}1525impl AstNode for Arg {1526	fn can_cast(kind: SyntaxKind) -> bool {1527		kind == ARG1528	}1529	fn cast(syntax: SyntaxNode) -> Option<Self> {1530		if Self::can_cast(syntax.kind()) {1531			Some(Self { syntax })1532		} else {1533			None1534		}1535	}1536	fn syntax(&self) -> &SyntaxNode {1537		&self.syntax1538	}1539}1540impl AstNode for ObjBodyComp {1541	fn can_cast(kind: SyntaxKind) -> bool {1542		kind == OBJ_BODY_COMP1543	}1544	fn cast(syntax: SyntaxNode) -> Option<Self> {1545		if Self::can_cast(syntax.kind()) {1546			Some(Self { syntax })1547		} else {1548			None1549		}1550	}1551	fn syntax(&self) -> &SyntaxNode {1552		&self.syntax1553	}1554}1555impl AstNode for ObjBodyMemberList {1556	fn can_cast(kind: SyntaxKind) -> bool {1557		kind == OBJ_BODY_MEMBER_LIST1558	}1559	fn cast(syntax: SyntaxNode) -> Option<Self> {1560		if Self::can_cast(syntax.kind()) {1561			Some(Self { syntax })1562		} else {1563			None1564		}1565	}1566	fn syntax(&self) -> &SyntaxNode {1567		&self.syntax1568	}1569}1570impl AstNode for MemberBindStmt {1571	fn can_cast(kind: SyntaxKind) -> bool {1572		kind == MEMBER_BIND_STMT1573	}1574	fn cast(syntax: SyntaxNode) -> Option<Self> {1575		if Self::can_cast(syntax.kind()) {1576			Some(Self { syntax })1577		} else {1578			None1579		}1580	}1581	fn syntax(&self) -> &SyntaxNode {1582		&self.syntax1583	}1584}1585impl AstNode for ObjLocal {1586	fn can_cast(kind: SyntaxKind) -> bool {1587		kind == OBJ_LOCAL1588	}1589	fn cast(syntax: SyntaxNode) -> Option<Self> {1590		if Self::can_cast(syntax.kind()) {1591			Some(Self { syntax })1592		} else {1593			None1594		}1595	}1596	fn syntax(&self) -> &SyntaxNode {1597		&self.syntax1598	}1599}1600impl AstNode for MemberAssertStmt {1601	fn can_cast(kind: SyntaxKind) -> bool {1602		kind == MEMBER_ASSERT_STMT1603	}1604	fn cast(syntax: SyntaxNode) -> Option<Self> {1605		if Self::can_cast(syntax.kind()) {1606			Some(Self { syntax })1607		} else {1608			None1609		}1610	}1611	fn syntax(&self) -> &SyntaxNode {1612		&self.syntax1613	}1614}1615impl AstNode for MemberFieldNormal {1616	fn can_cast(kind: SyntaxKind) -> bool {1617		kind == MEMBER_FIELD_NORMAL1618	}1619	fn cast(syntax: SyntaxNode) -> Option<Self> {1620		if Self::can_cast(syntax.kind()) {1621			Some(Self { syntax })1622		} else {1623			None1624		}1625	}1626	fn syntax(&self) -> &SyntaxNode {1627		&self.syntax1628	}1629}1630impl AstNode for MemberFieldMethod {1631	fn can_cast(kind: SyntaxKind) -> bool {1632		kind == MEMBER_FIELD_METHOD1633	}1634	fn cast(syntax: SyntaxNode) -> Option<Self> {1635		if Self::can_cast(syntax.kind()) {1636			Some(Self { syntax })1637		} else {1638			None1639		}1640	}1641	fn syntax(&self) -> &SyntaxNode {1642		&self.syntax1643	}1644}1645impl AstNode for FieldNameFixed {1646	fn can_cast(kind: SyntaxKind) -> bool {1647		kind == FIELD_NAME_FIXED1648	}1649	fn cast(syntax: SyntaxNode) -> Option<Self> {1650		if Self::can_cast(syntax.kind()) {1651			Some(Self { syntax })1652		} else {1653			None1654		}1655	}1656	fn syntax(&self) -> &SyntaxNode {1657		&self.syntax1658	}1659}1660impl AstNode for FieldNameDynamic {1661	fn can_cast(kind: SyntaxKind) -> bool {1662		kind == FIELD_NAME_DYNAMIC1663	}1664	fn cast(syntax: SyntaxNode) -> Option<Self> {1665		if Self::can_cast(syntax.kind()) {1666			Some(Self { syntax })1667		} else {1668			None1669		}1670	}1671	fn syntax(&self) -> &SyntaxNode {1672		&self.syntax1673	}1674}1675impl AstNode for ForSpec {1676	fn can_cast(kind: SyntaxKind) -> bool {1677		kind == FOR_SPEC1678	}1679	fn cast(syntax: SyntaxNode) -> Option<Self> {1680		if Self::can_cast(syntax.kind()) {1681			Some(Self { syntax })1682		} else {1683			None1684		}1685	}1686	fn syntax(&self) -> &SyntaxNode {1687		&self.syntax1688	}1689}1690impl AstNode for IfSpec {1691	fn can_cast(kind: SyntaxKind) -> bool {1692		kind == IF_SPEC1693	}1694	fn cast(syntax: SyntaxNode) -> Option<Self> {1695		if Self::can_cast(syntax.kind()) {1696			Some(Self { syntax })1697		} else {1698			None1699		}1700	}1701	fn syntax(&self) -> &SyntaxNode {1702		&self.syntax1703	}1704}1705impl AstNode for BindDestruct {1706	fn can_cast(kind: SyntaxKind) -> bool {1707		kind == BIND_DESTRUCT1708	}1709	fn cast(syntax: SyntaxNode) -> Option<Self> {1710		if Self::can_cast(syntax.kind()) {1711			Some(Self { syntax })1712		} else {1713			None1714		}1715	}1716	fn syntax(&self) -> &SyntaxNode {1717		&self.syntax1718	}1719}1720impl AstNode for BindFunction {1721	fn can_cast(kind: SyntaxKind) -> bool {1722		kind == BIND_FUNCTION1723	}1724	fn cast(syntax: SyntaxNode) -> Option<Self> {1725		if Self::can_cast(syntax.kind()) {1726			Some(Self { syntax })1727		} else {1728			None1729		}1730	}1731	fn syntax(&self) -> &SyntaxNode {1732		&self.syntax1733	}1734}1735impl AstNode for Param {1736	fn can_cast(kind: SyntaxKind) -> bool {1737		kind == PARAM1738	}1739	fn cast(syntax: SyntaxNode) -> Option<Self> {1740		if Self::can_cast(syntax.kind()) {1741			Some(Self { syntax })1742		} else {1743			None1744		}1745	}1746	fn syntax(&self) -> &SyntaxNode {1747		&self.syntax1748	}1749}1750impl AstNode for DestructFull {1751	fn can_cast(kind: SyntaxKind) -> bool {1752		kind == DESTRUCT_FULL1753	}1754	fn cast(syntax: SyntaxNode) -> Option<Self> {1755		if Self::can_cast(syntax.kind()) {1756			Some(Self { syntax })1757		} else {1758			None1759		}1760	}1761	fn syntax(&self) -> &SyntaxNode {1762		&self.syntax1763	}1764}1765impl AstNode for DestructSkip {1766	fn can_cast(kind: SyntaxKind) -> bool {1767		kind == DESTRUCT_SKIP1768	}1769	fn cast(syntax: SyntaxNode) -> Option<Self> {1770		if Self::can_cast(syntax.kind()) {1771			Some(Self { syntax })1772		} else {1773			None1774		}1775	}1776	fn syntax(&self) -> &SyntaxNode {1777		&self.syntax1778	}1779}1780impl AstNode for DestructArray {1781	fn can_cast(kind: SyntaxKind) -> bool {1782		kind == DESTRUCT_ARRAY1783	}1784	fn cast(syntax: SyntaxNode) -> Option<Self> {1785		if Self::can_cast(syntax.kind()) {1786			Some(Self { syntax })1787		} else {1788			None1789		}1790	}1791	fn syntax(&self) -> &SyntaxNode {1792		&self.syntax1793	}1794}1795impl AstNode for DestructObject {1796	fn can_cast(kind: SyntaxKind) -> bool {1797		kind == DESTRUCT_OBJECT1798	}1799	fn cast(syntax: SyntaxNode) -> Option<Self> {1800		if Self::can_cast(syntax.kind()) {1801			Some(Self { syntax })1802		} else {1803			None1804		}1805	}1806	fn syntax(&self) -> &SyntaxNode {1807		&self.syntax1808	}1809}1810impl AstNode for DestructObjectField {1811	fn can_cast(kind: SyntaxKind) -> bool {1812		kind == DESTRUCT_OBJECT_FIELD1813	}1814	fn cast(syntax: SyntaxNode) -> Option<Self> {1815		if Self::can_cast(syntax.kind()) {1816			Some(Self { syntax })1817		} else {1818			None1819		}1820	}1821	fn syntax(&self) -> &SyntaxNode {1822		&self.syntax1823	}1824}1825impl AstNode for DestructRest {1826	fn can_cast(kind: SyntaxKind) -> bool {1827		kind == DESTRUCT_REST1828	}1829	fn cast(syntax: SyntaxNode) -> Option<Self> {1830		if Self::can_cast(syntax.kind()) {1831			Some(Self { syntax })1832		} else {1833			None1834		}1835	}1836	fn syntax(&self) -> &SyntaxNode {1837		&self.syntax1838	}1839}1840impl AstNode for DestructArrayElement {1841	fn can_cast(kind: SyntaxKind) -> bool {1842		kind == DESTRUCT_ARRAY_ELEMENT1843	}1844	fn cast(syntax: SyntaxNode) -> Option<Self> {1845		if Self::can_cast(syntax.kind()) {1846			Some(Self { syntax })1847		} else {1848			None1849		}1850	}1851	fn syntax(&self) -> &SyntaxNode {1852		&self.syntax1853	}1854}1855impl From<SuffixIndex> for Suffix {1856	fn from(node: SuffixIndex) -> Suffix {1857		Suffix::SuffixIndex(node)1858	}1859}1860impl From<SuffixIndexExpr> for Suffix {1861	fn from(node: SuffixIndexExpr) -> Suffix {1862		Suffix::SuffixIndexExpr(node)1863	}1864}1865impl From<SuffixSlice> for Suffix {1866	fn from(node: SuffixSlice) -> Suffix {1867		Suffix::SuffixSlice(node)1868	}1869}1870impl From<SuffixApply> for Suffix {1871	fn from(node: SuffixApply) -> Suffix {1872		Suffix::SuffixApply(node)1873	}1874}1875impl AstNode for Suffix {1876	fn can_cast(kind: SyntaxKind) -> bool {1877		match kind {1878			SUFFIX_INDEX | SUFFIX_INDEX_EXPR | SUFFIX_SLICE | SUFFIX_APPLY => true,1879			_ => false,1880		}1881	}1882	fn cast(syntax: SyntaxNode) -> Option<Self> {1883		let res = match syntax.kind() {1884			SUFFIX_INDEX => Suffix::SuffixIndex(SuffixIndex { syntax }),1885			SUFFIX_INDEX_EXPR => Suffix::SuffixIndexExpr(SuffixIndexExpr { syntax }),1886			SUFFIX_SLICE => Suffix::SuffixSlice(SuffixSlice { syntax }),1887			SUFFIX_APPLY => Suffix::SuffixApply(SuffixApply { syntax }),1888			_ => return None,1889		};1890		Some(res)1891	}1892	fn syntax(&self) -> &SyntaxNode {1893		match self {1894			Suffix::SuffixIndex(it) => &it.syntax,1895			Suffix::SuffixIndexExpr(it) => &it.syntax,1896			Suffix::SuffixSlice(it) => &it.syntax,1897			Suffix::SuffixApply(it) => &it.syntax,1898		}1899	}1900}1901impl From<BindDestruct> for Bind {1902	fn from(node: BindDestruct) -> Bind {1903		Bind::BindDestruct(node)1904	}1905}1906impl From<BindFunction> for Bind {1907	fn from(node: BindFunction) -> Bind {1908		Bind::BindFunction(node)1909	}1910}1911impl AstNode for Bind {1912	fn can_cast(kind: SyntaxKind) -> bool {1913		match kind {1914			BIND_DESTRUCT | BIND_FUNCTION => true,1915			_ => false,1916		}1917	}1918	fn cast(syntax: SyntaxNode) -> Option<Self> {1919		let res = match syntax.kind() {1920			BIND_DESTRUCT => Bind::BindDestruct(BindDestruct { syntax }),1921			BIND_FUNCTION => Bind::BindFunction(BindFunction { syntax }),1922			_ => return None,1923		};1924		Some(res)1925	}1926	fn syntax(&self) -> &SyntaxNode {1927		match self {1928			Bind::BindDestruct(it) => &it.syntax,1929			Bind::BindFunction(it) => &it.syntax,1930		}1931	}1932}1933impl From<StmtLocal> for Stmt {1934	fn from(node: StmtLocal) -> Stmt {1935		Stmt::StmtLocal(node)1936	}1937}1938impl From<StmtAssert> for Stmt {1939	fn from(node: StmtAssert) -> Stmt {1940		Stmt::StmtAssert(node)1941	}1942}1943impl AstNode for Stmt {1944	fn can_cast(kind: SyntaxKind) -> bool {1945		match kind {1946			STMT_LOCAL | STMT_ASSERT => true,1947			_ => false,1948		}1949	}1950	fn cast(syntax: SyntaxNode) -> Option<Self> {1951		let res = match syntax.kind() {1952			STMT_LOCAL => Stmt::StmtLocal(StmtLocal { syntax }),1953			STMT_ASSERT => Stmt::StmtAssert(StmtAssert { syntax }),1954			_ => return None,1955		};1956		Some(res)1957	}1958	fn syntax(&self) -> &SyntaxNode {1959		match self {1960			Stmt::StmtLocal(it) => &it.syntax,1961			Stmt::StmtAssert(it) => &it.syntax,1962		}1963	}1964}1965impl From<ObjBodyComp> for ObjBody {1966	fn from(node: ObjBodyComp) -> ObjBody {1967		ObjBody::ObjBodyComp(node)1968	}1969}1970impl From<ObjBodyMemberList> for ObjBody {1971	fn from(node: ObjBodyMemberList) -> ObjBody {1972		ObjBody::ObjBodyMemberList(node)1973	}1974}1975impl AstNode for ObjBody {1976	fn can_cast(kind: SyntaxKind) -> bool {1977		match kind {1978			OBJ_BODY_COMP | OBJ_BODY_MEMBER_LIST => true,1979			_ => false,1980		}1981	}1982	fn cast(syntax: SyntaxNode) -> Option<Self> {1983		let res = match syntax.kind() {1984			OBJ_BODY_COMP => ObjBody::ObjBodyComp(ObjBodyComp { syntax }),1985			OBJ_BODY_MEMBER_LIST => ObjBody::ObjBodyMemberList(ObjBodyMemberList { syntax }),1986			_ => return None,1987		};1988		Some(res)1989	}1990	fn syntax(&self) -> &SyntaxNode {1991		match self {1992			ObjBody::ObjBodyComp(it) => &it.syntax,1993			ObjBody::ObjBodyMemberList(it) => &it.syntax,1994		}1995	}1996}1997impl From<ForSpec> for CompSpec {1998	fn from(node: ForSpec) -> CompSpec {1999		CompSpec::ForSpec(node)2000	}2001}2002impl From<IfSpec> for CompSpec {2003	fn from(node: IfSpec) -> CompSpec {2004		CompSpec::IfSpec(node)2005	}2006}2007impl AstNode for CompSpec {2008	fn can_cast(kind: SyntaxKind) -> bool {2009		match kind {2010			FOR_SPEC | IF_SPEC => true,2011			_ => false,2012		}2013	}2014	fn cast(syntax: SyntaxNode) -> Option<Self> {2015		let res = match syntax.kind() {2016			FOR_SPEC => CompSpec::ForSpec(ForSpec { syntax }),2017			IF_SPEC => CompSpec::IfSpec(IfSpec { syntax }),2018			_ => return None,2019		};2020		Some(res)2021	}2022	fn syntax(&self) -> &SyntaxNode {2023		match self {2024			CompSpec::ForSpec(it) => &it.syntax,2025			CompSpec::IfSpec(it) => &it.syntax,2026		}2027	}2028}2029impl From<ExprBinary> for ExprBase {2030	fn from(node: ExprBinary) -> ExprBase {2031		ExprBase::ExprBinary(node)2032	}2033}2034impl From<ExprUnary> for ExprBase {2035	fn from(node: ExprUnary) -> ExprBase {2036		ExprBase::ExprUnary(node)2037	}2038}2039impl From<ExprObjExtend> for ExprBase {2040	fn from(node: ExprObjExtend) -> ExprBase {2041		ExprBase::ExprObjExtend(node)2042	}2043}2044impl From<ExprParened> for ExprBase {2045	fn from(node: ExprParened) -> ExprBase {2046		ExprBase::ExprParened(node)2047	}2048}2049impl From<ExprString> for ExprBase {2050	fn from(node: ExprString) -> ExprBase {2051		ExprBase::ExprString(node)2052	}2053}2054impl From<ExprNumber> for ExprBase {2055	fn from(node: ExprNumber) -> ExprBase {2056		ExprBase::ExprNumber(node)2057	}2058}2059impl From<ExprLiteral> for ExprBase {2060	fn from(node: ExprLiteral) -> ExprBase {2061		ExprBase::ExprLiteral(node)2062	}2063}2064impl From<ExprArray> for ExprBase {2065	fn from(node: ExprArray) -> ExprBase {2066		ExprBase::ExprArray(node)2067	}2068}2069impl From<ExprObject> for ExprBase {2070	fn from(node: ExprObject) -> ExprBase {2071		ExprBase::ExprObject(node)2072	}2073}2074impl From<ExprArrayComp> for ExprBase {2075	fn from(node: ExprArrayComp) -> ExprBase {2076		ExprBase::ExprArrayComp(node)2077	}2078}2079impl From<ExprImport> for ExprBase {2080	fn from(node: ExprImport) -> ExprBase {2081		ExprBase::ExprImport(node)2082	}2083}2084impl From<ExprVar> for ExprBase {2085	fn from(node: ExprVar) -> ExprBase {2086		ExprBase::ExprVar(node)2087	}2088}2089impl From<ExprIfThenElse> for ExprBase {2090	fn from(node: ExprIfThenElse) -> ExprBase {2091		ExprBase::ExprIfThenElse(node)2092	}2093}2094impl From<ExprFunction> for ExprBase {2095	fn from(node: ExprFunction) -> ExprBase {2096		ExprBase::ExprFunction(node)2097	}2098}2099impl From<ExprError> for ExprBase {2100	fn from(node: ExprError) -> ExprBase {2101		ExprBase::ExprError(node)2102	}2103}2104impl AstNode for ExprBase {2105	fn can_cast(kind: SyntaxKind) -> bool {2106		match kind {2107			EXPR_BINARY | EXPR_UNARY | EXPR_OBJ_EXTEND | EXPR_PARENED | EXPR_STRING2108			| EXPR_NUMBER | EXPR_LITERAL | EXPR_ARRAY | EXPR_OBJECT | EXPR_ARRAY_COMP2109			| EXPR_IMPORT | EXPR_VAR | EXPR_IF_THEN_ELSE | EXPR_FUNCTION | EXPR_ERROR => true,2110			_ => false,2111		}2112	}2113	fn cast(syntax: SyntaxNode) -> Option<Self> {2114		let res = match syntax.kind() {2115			EXPR_BINARY => ExprBase::ExprBinary(ExprBinary { syntax }),2116			EXPR_UNARY => ExprBase::ExprUnary(ExprUnary { syntax }),2117			EXPR_OBJ_EXTEND => ExprBase::ExprObjExtend(ExprObjExtend { syntax }),2118			EXPR_PARENED => ExprBase::ExprParened(ExprParened { syntax }),2119			EXPR_STRING => ExprBase::ExprString(ExprString { syntax }),2120			EXPR_NUMBER => ExprBase::ExprNumber(ExprNumber { syntax }),2121			EXPR_LITERAL => ExprBase::ExprLiteral(ExprLiteral { syntax }),2122			EXPR_ARRAY => ExprBase::ExprArray(ExprArray { syntax }),2123			EXPR_OBJECT => ExprBase::ExprObject(ExprObject { syntax }),2124			EXPR_ARRAY_COMP => ExprBase::ExprArrayComp(ExprArrayComp { syntax }),2125			EXPR_IMPORT => ExprBase::ExprImport(ExprImport { syntax }),2126			EXPR_VAR => ExprBase::ExprVar(ExprVar { syntax }),2127			EXPR_IF_THEN_ELSE => ExprBase::ExprIfThenElse(ExprIfThenElse { syntax }),2128			EXPR_FUNCTION => ExprBase::ExprFunction(ExprFunction { syntax }),2129			EXPR_ERROR => ExprBase::ExprError(ExprError { syntax }),2130			_ => return None,2131		};2132		Some(res)2133	}2134	fn syntax(&self) -> &SyntaxNode {2135		match self {2136			ExprBase::ExprBinary(it) => &it.syntax,2137			ExprBase::ExprUnary(it) => &it.syntax,2138			ExprBase::ExprObjExtend(it) => &it.syntax,2139			ExprBase::ExprParened(it) => &it.syntax,2140			ExprBase::ExprString(it) => &it.syntax,2141			ExprBase::ExprNumber(it) => &it.syntax,2142			ExprBase::ExprLiteral(it) => &it.syntax,2143			ExprBase::ExprArray(it) => &it.syntax,2144			ExprBase::ExprObject(it) => &it.syntax,2145			ExprBase::ExprArrayComp(it) => &it.syntax,2146			ExprBase::ExprImport(it) => &it.syntax,2147			ExprBase::ExprVar(it) => &it.syntax,2148			ExprBase::ExprIfThenElse(it) => &it.syntax,2149			ExprBase::ExprFunction(it) => &it.syntax,2150			ExprBase::ExprError(it) => &it.syntax,2151		}2152	}2153}2154impl From<MemberBindStmt> for MemberComp {2155	fn from(node: MemberBindStmt) -> MemberComp {2156		MemberComp::MemberBindStmt(node)2157	}2158}2159impl From<MemberFieldNormal> for MemberComp {2160	fn from(node: MemberFieldNormal) -> MemberComp {2161		MemberComp::MemberFieldNormal(node)2162	}2163}2164impl From<MemberFieldMethod> for MemberComp {2165	fn from(node: MemberFieldMethod) -> MemberComp {2166		MemberComp::MemberFieldMethod(node)2167	}2168}2169impl AstNode for MemberComp {2170	fn can_cast(kind: SyntaxKind) -> bool {2171		match kind {2172			MEMBER_BIND_STMT | MEMBER_FIELD_NORMAL | MEMBER_FIELD_METHOD => true,2173			_ => false,2174		}2175	}2176	fn cast(syntax: SyntaxNode) -> Option<Self> {2177		let res = match syntax.kind() {2178			MEMBER_BIND_STMT => MemberComp::MemberBindStmt(MemberBindStmt { syntax }),2179			MEMBER_FIELD_NORMAL => MemberComp::MemberFieldNormal(MemberFieldNormal { syntax }),2180			MEMBER_FIELD_METHOD => MemberComp::MemberFieldMethod(MemberFieldMethod { syntax }),2181			_ => return None,2182		};2183		Some(res)2184	}2185	fn syntax(&self) -> &SyntaxNode {2186		match self {2187			MemberComp::MemberBindStmt(it) => &it.syntax,2188			MemberComp::MemberFieldNormal(it) => &it.syntax,2189			MemberComp::MemberFieldMethod(it) => &it.syntax,2190		}2191	}2192}2193impl From<MemberBindStmt> for Member {2194	fn from(node: MemberBindStmt) -> Member {2195		Member::MemberBindStmt(node)2196	}2197}2198impl From<MemberAssertStmt> for Member {2199	fn from(node: MemberAssertStmt) -> Member {2200		Member::MemberAssertStmt(node)2201	}2202}2203impl From<MemberFieldNormal> for Member {2204	fn from(node: MemberFieldNormal) -> Member {2205		Member::MemberFieldNormal(node)2206	}2207}2208impl From<MemberFieldMethod> for Member {2209	fn from(node: MemberFieldMethod) -> Member {2210		Member::MemberFieldMethod(node)2211	}2212}2213impl AstNode for Member {2214	fn can_cast(kind: SyntaxKind) -> bool {2215		match kind {2216			MEMBER_BIND_STMT | MEMBER_ASSERT_STMT | MEMBER_FIELD_NORMAL | MEMBER_FIELD_METHOD => {2217				true2218			}2219			_ => false,2220		}2221	}2222	fn cast(syntax: SyntaxNode) -> Option<Self> {2223		let res = match syntax.kind() {2224			MEMBER_BIND_STMT => Member::MemberBindStmt(MemberBindStmt { syntax }),2225			MEMBER_ASSERT_STMT => Member::MemberAssertStmt(MemberAssertStmt { syntax }),2226			MEMBER_FIELD_NORMAL => Member::MemberFieldNormal(MemberFieldNormal { syntax }),2227			MEMBER_FIELD_METHOD => Member::MemberFieldMethod(MemberFieldMethod { syntax }),2228			_ => return None,2229		};2230		Some(res)2231	}2232	fn syntax(&self) -> &SyntaxNode {2233		match self {2234			Member::MemberBindStmt(it) => &it.syntax,2235			Member::MemberAssertStmt(it) => &it.syntax,2236			Member::MemberFieldNormal(it) => &it.syntax,2237			Member::MemberFieldMethod(it) => &it.syntax,2238		}2239	}2240}2241impl From<FieldNameFixed> for FieldName {2242	fn from(node: FieldNameFixed) -> FieldName {2243		FieldName::FieldNameFixed(node)2244	}2245}2246impl From<FieldNameDynamic> for FieldName {2247	fn from(node: FieldNameDynamic) -> FieldName {2248		FieldName::FieldNameDynamic(node)2249	}2250}2251impl AstNode for FieldName {2252	fn can_cast(kind: SyntaxKind) -> bool {2253		match kind {2254			FIELD_NAME_FIXED | FIELD_NAME_DYNAMIC => true,2255			_ => false,2256		}2257	}2258	fn cast(syntax: SyntaxNode) -> Option<Self> {2259		let res = match syntax.kind() {2260			FIELD_NAME_FIXED => FieldName::FieldNameFixed(FieldNameFixed { syntax }),2261			FIELD_NAME_DYNAMIC => FieldName::FieldNameDynamic(FieldNameDynamic { syntax }),2262			_ => return None,2263		};2264		Some(res)2265	}2266	fn syntax(&self) -> &SyntaxNode {2267		match self {2268			FieldName::FieldNameFixed(it) => &it.syntax,2269			FieldName::FieldNameDynamic(it) => &it.syntax,2270		}2271	}2272}2273impl From<DestructFull> for Destruct {2274	fn from(node: DestructFull) -> Destruct {2275		Destruct::DestructFull(node)2276	}2277}2278impl From<DestructSkip> for Destruct {2279	fn from(node: DestructSkip) -> Destruct {2280		Destruct::DestructSkip(node)2281	}2282}2283impl From<DestructArray> for Destruct {2284	fn from(node: DestructArray) -> Destruct {2285		Destruct::DestructArray(node)2286	}2287}2288impl From<DestructObject> for Destruct {2289	fn from(node: DestructObject) -> Destruct {2290		Destruct::DestructObject(node)2291	}2292}2293impl AstNode for Destruct {2294	fn can_cast(kind: SyntaxKind) -> bool {2295		match kind {2296			DESTRUCT_FULL | DESTRUCT_SKIP | DESTRUCT_ARRAY | DESTRUCT_OBJECT => true,2297			_ => false,2298		}2299	}2300	fn cast(syntax: SyntaxNode) -> Option<Self> {2301		let res = match syntax.kind() {2302			DESTRUCT_FULL => Destruct::DestructFull(DestructFull { syntax }),2303			DESTRUCT_SKIP => Destruct::DestructSkip(DestructSkip { syntax }),2304			DESTRUCT_ARRAY => Destruct::DestructArray(DestructArray { syntax }),2305			DESTRUCT_OBJECT => Destruct::DestructObject(DestructObject { syntax }),2306			_ => return None,2307		};2308		Some(res)2309	}2310	fn syntax(&self) -> &SyntaxNode {2311		match self {2312			Destruct::DestructFull(it) => &it.syntax,2313			Destruct::DestructSkip(it) => &it.syntax,2314			Destruct::DestructArray(it) => &it.syntax,2315			Destruct::DestructObject(it) => &it.syntax,2316		}2317	}2318}2319impl From<DestructArrayElement> for DestructArrayPart {2320	fn from(node: DestructArrayElement) -> DestructArrayPart {2321		DestructArrayPart::DestructArrayElement(node)2322	}2323}2324impl From<DestructRest> for DestructArrayPart {2325	fn from(node: DestructRest) -> DestructArrayPart {2326		DestructArrayPart::DestructRest(node)2327	}2328}2329impl AstNode for DestructArrayPart {2330	fn can_cast(kind: SyntaxKind) -> bool {2331		match kind {2332			DESTRUCT_ARRAY_ELEMENT | DESTRUCT_REST => true,2333			_ => false,2334		}2335	}2336	fn cast(syntax: SyntaxNode) -> Option<Self> {2337		let res = match syntax.kind() {2338			DESTRUCT_ARRAY_ELEMENT => {2339				DestructArrayPart::DestructArrayElement(DestructArrayElement { syntax })2340			}2341			DESTRUCT_REST => DestructArrayPart::DestructRest(DestructRest { syntax }),2342			_ => return None,2343		};2344		Some(res)2345	}2346	fn syntax(&self) -> &SyntaxNode {2347		match self {2348			DestructArrayPart::DestructArrayElement(it) => &it.syntax,2349			DestructArrayPart::DestructRest(it) => &it.syntax,2350		}2351	}2352}2353impl AstToken for BinaryOperator {2354	fn can_cast(kind: SyntaxKind) -> bool {2355		BinaryOperatorKind::can_cast(kind)2356	}2357	fn cast(syntax: SyntaxToken) -> Option<Self> {2358		let kind = BinaryOperatorKind::cast(syntax.kind())?;2359		Some(BinaryOperator { syntax, kind })2360	}2361	fn syntax(&self) -> &SyntaxToken {2362		&self.syntax2363	}2364}2365impl BinaryOperatorKind {2366	fn can_cast(kind: SyntaxKind) -> bool {2367		match kind {2368			OR | NULL_COAELSE | AND | BIT_OR | BIT_XOR | BIT_AND | EQ | NE | LT | GT | LE | GE2369			| IN_KW | LHS | RHS | PLUS | MINUS | MUL | DIV | MODULO | META_OBJECT_APPLY2370			| ERROR_NO_OPERATOR => true,2371			_ => false,2372		}2373	}2374	pub fn cast(kind: SyntaxKind) -> Option<Self> {2375		let res = match kind {2376			OR => Self::Or,2377			NULL_COAELSE => Self::NullCoaelse,2378			AND => Self::And,2379			BIT_OR => Self::BitOr,2380			BIT_XOR => Self::BitXor,2381			BIT_AND => Self::BitAnd,2382			EQ => Self::Eq,2383			NE => Self::Ne,2384			LT => Self::Lt,2385			GT => Self::Gt,2386			LE => Self::Le,2387			GE => Self::Ge,2388			IN_KW => Self::InKw,2389			LHS => Self::Lhs,2390			RHS => Self::Rhs,2391			PLUS => Self::Plus,2392			MINUS => Self::Minus,2393			MUL => Self::Mul,2394			DIV => Self::Div,2395			MODULO => Self::Modulo,2396			META_OBJECT_APPLY => Self::MetaObjectApply,2397			ERROR_NO_OPERATOR => Self::ErrorNoOperator,2398			_ => return None,2399		};2400		Some(res)2401	}2402}2403impl BinaryOperator {2404	pub fn kind(&self) -> BinaryOperatorKind {2405		self.kind2406	}2407}2408impl std::fmt::Display for BinaryOperator {2409	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2410		std::fmt::Display::fmt(self.syntax(), f)2411	}2412}2413impl AstToken for UnaryOperator {2414	fn can_cast(kind: SyntaxKind) -> bool {2415		UnaryOperatorKind::can_cast(kind)2416	}2417	fn cast(syntax: SyntaxToken) -> Option<Self> {2418		let kind = UnaryOperatorKind::cast(syntax.kind())?;2419		Some(UnaryOperator { syntax, kind })2420	}2421	fn syntax(&self) -> &SyntaxToken {2422		&self.syntax2423	}2424}2425impl UnaryOperatorKind {2426	fn can_cast(kind: SyntaxKind) -> bool {2427		match kind {2428			MINUS | NOT | BIT_NOT => true,2429			_ => false,2430		}2431	}2432	pub fn cast(kind: SyntaxKind) -> Option<Self> {2433		let res = match kind {2434			MINUS => Self::Minus,2435			NOT => Self::Not,2436			BIT_NOT => Self::BitNot,2437			_ => return None,2438		};2439		Some(res)2440	}2441}2442impl UnaryOperator {2443	pub fn kind(&self) -> UnaryOperatorKind {2444		self.kind2445	}2446}2447impl std::fmt::Display for UnaryOperator {2448	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2449		std::fmt::Display::fmt(self.syntax(), f)2450	}2451}2452impl AstToken for Literal {2453	fn can_cast(kind: SyntaxKind) -> bool {2454		LiteralKind::can_cast(kind)2455	}2456	fn cast(syntax: SyntaxToken) -> Option<Self> {2457		let kind = LiteralKind::cast(syntax.kind())?;2458		Some(Literal { syntax, kind })2459	}2460	fn syntax(&self) -> &SyntaxToken {2461		&self.syntax2462	}2463}2464impl LiteralKind {2465	fn can_cast(kind: SyntaxKind) -> bool {2466		match kind {2467			NULL_KW | TRUE_KW | FALSE_KW | SELF_KW | DOLLAR | SUPER_KW => true,2468			_ => false,2469		}2470	}2471	pub fn cast(kind: SyntaxKind) -> Option<Self> {2472		let res = match kind {2473			NULL_KW => Self::NullKw,2474			TRUE_KW => Self::TrueKw,2475			FALSE_KW => Self::FalseKw,2476			SELF_KW => Self::SelfKw,2477			DOLLAR => Self::Dollar,2478			SUPER_KW => Self::SuperKw,2479			_ => return None,2480		};2481		Some(res)2482	}2483}2484impl Literal {2485	pub fn kind(&self) -> LiteralKind {2486		self.kind2487	}2488}2489impl std::fmt::Display for Literal {2490	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2491		std::fmt::Display::fmt(self.syntax(), f)2492	}2493}2494impl AstToken for Text {2495	fn can_cast(kind: SyntaxKind) -> bool {2496		TextKind::can_cast(kind)2497	}2498	fn cast(syntax: SyntaxToken) -> Option<Self> {2499		let kind = TextKind::cast(syntax.kind())?;2500		Some(Text { syntax, kind })2501	}2502	fn syntax(&self) -> &SyntaxToken {2503		&self.syntax2504	}2505}2506impl TextKind {2507	fn can_cast(kind: SyntaxKind) -> bool {2508		match kind {2509			STRING_DOUBLE2510			| ERROR_STRING_DOUBLE_UNTERMINATED2511			| STRING_SINGLE2512			| ERROR_STRING_SINGLE_UNTERMINATED2513			| STRING_DOUBLE_VERBATIM2514			| ERROR_STRING_DOUBLE_VERBATIM_UNTERMINATED2515			| STRING_SINGLE_VERBATIM2516			| ERROR_STRING_SINGLE_VERBATIM_UNTERMINATED2517			| ERROR_STRING_VERBATIM_MISSING_QUOTES2518			| STRING_BLOCK2519			| ERROR_STRING_BLOCK_UNEXPECTED_END2520			| ERROR_STRING_BLOCK_MISSING_NEW_LINE2521			| ERROR_STRING_BLOCK_MISSING_TERMINATION2522			| ERROR_STRING_BLOCK_MISSING_INDENT => true,2523			_ => false,2524		}2525	}2526	pub fn cast(kind: SyntaxKind) -> Option<Self> {2527		let res = match kind {2528			STRING_DOUBLE => Self::StringDouble,2529			ERROR_STRING_DOUBLE_UNTERMINATED => Self::ErrorStringDoubleUnterminated,2530			STRING_SINGLE => Self::StringSingle,2531			ERROR_STRING_SINGLE_UNTERMINATED => Self::ErrorStringSingleUnterminated,2532			STRING_DOUBLE_VERBATIM => Self::StringDoubleVerbatim,2533			ERROR_STRING_DOUBLE_VERBATIM_UNTERMINATED => {2534				Self::ErrorStringDoubleVerbatimUnterminated2535			}2536			STRING_SINGLE_VERBATIM => Self::StringSingleVerbatim,2537			ERROR_STRING_SINGLE_VERBATIM_UNTERMINATED => {2538				Self::ErrorStringSingleVerbatimUnterminated2539			}2540			ERROR_STRING_VERBATIM_MISSING_QUOTES => Self::ErrorStringVerbatimMissingQuotes,2541			STRING_BLOCK => Self::StringBlock,2542			ERROR_STRING_BLOCK_UNEXPECTED_END => Self::ErrorStringBlockUnexpectedEnd,2543			ERROR_STRING_BLOCK_MISSING_NEW_LINE => Self::ErrorStringBlockMissingNewLine,2544			ERROR_STRING_BLOCK_MISSING_TERMINATION => Self::ErrorStringBlockMissingTermination,2545			ERROR_STRING_BLOCK_MISSING_INDENT => Self::ErrorStringBlockMissingIndent,2546			_ => return None,2547		};2548		Some(res)2549	}2550}2551impl Text {2552	pub fn kind(&self) -> TextKind {2553		self.kind2554	}2555}2556impl std::fmt::Display for Text {2557	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2558		std::fmt::Display::fmt(self.syntax(), f)2559	}2560}2561impl AstToken for Number {2562	fn can_cast(kind: SyntaxKind) -> bool {2563		NumberKind::can_cast(kind)2564	}2565	fn cast(syntax: SyntaxToken) -> Option<Self> {2566		let kind = NumberKind::cast(syntax.kind())?;2567		Some(Number { syntax, kind })2568	}2569	fn syntax(&self) -> &SyntaxToken {2570		&self.syntax2571	}2572}2573impl NumberKind {2574	fn can_cast(kind: SyntaxKind) -> bool {2575		match kind {2576			FLOAT2577			| ERROR_FLOAT_JUNK_AFTER_POINT2578			| ERROR_FLOAT_JUNK_AFTER_EXPONENT2579			| ERROR_FLOAT_JUNK_AFTER_EXPONENT_SIGN => true,2580			_ => false,2581		}2582	}2583	pub fn cast(kind: SyntaxKind) -> Option<Self> {2584		let res = match kind {2585			FLOAT => Self::Float,2586			ERROR_FLOAT_JUNK_AFTER_POINT => Self::ErrorFloatJunkAfterPoint,2587			ERROR_FLOAT_JUNK_AFTER_EXPONENT => Self::ErrorFloatJunkAfterExponent,2588			ERROR_FLOAT_JUNK_AFTER_EXPONENT_SIGN => Self::ErrorFloatJunkAfterExponentSign,2589			_ => return None,2590		};2591		Some(res)2592	}2593}2594impl Number {2595	pub fn kind(&self) -> NumberKind {2596		self.kind2597	}2598}2599impl std::fmt::Display for Number {2600	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2601		std::fmt::Display::fmt(self.syntax(), f)2602	}2603}2604impl AstToken for ImportKind {2605	fn can_cast(kind: SyntaxKind) -> bool {2606		ImportKindKind::can_cast(kind)2607	}2608	fn cast(syntax: SyntaxToken) -> Option<Self> {2609		let kind = ImportKindKind::cast(syntax.kind())?;2610		Some(ImportKind { syntax, kind })2611	}2612	fn syntax(&self) -> &SyntaxToken {2613		&self.syntax2614	}2615}2616impl ImportKindKind {2617	fn can_cast(kind: SyntaxKind) -> bool {2618		match kind {2619			IMPORTSTR_KW | IMPORTBIN_KW | IMPORT_KW => true,2620			_ => false,2621		}2622	}2623	pub fn cast(kind: SyntaxKind) -> Option<Self> {2624		let res = match kind {2625			IMPORTSTR_KW => Self::ImportstrKw,2626			IMPORTBIN_KW => Self::ImportbinKw,2627			IMPORT_KW => Self::ImportKw,2628			_ => return None,2629		};2630		Some(res)2631	}2632}2633impl ImportKind {2634	pub fn kind(&self) -> ImportKindKind {2635		self.kind2636	}2637}2638impl std::fmt::Display for ImportKind {2639	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2640		std::fmt::Display::fmt(self.syntax(), f)2641	}2642}2643impl AstToken for Visibility {2644	fn can_cast(kind: SyntaxKind) -> bool {2645		VisibilityKind::can_cast(kind)2646	}2647	fn cast(syntax: SyntaxToken) -> Option<Self> {2648		let kind = VisibilityKind::cast(syntax.kind())?;2649		Some(Visibility { syntax, kind })2650	}2651	fn syntax(&self) -> &SyntaxToken {2652		&self.syntax2653	}2654}2655impl VisibilityKind {2656	fn can_cast(kind: SyntaxKind) -> bool {2657		match kind {2658			COLONCOLONCOLON | COLONCOLON | COLON => true,2659			_ => false,2660		}2661	}2662	pub fn cast(kind: SyntaxKind) -> Option<Self> {2663		let res = match kind {2664			COLONCOLONCOLON => Self::Coloncoloncolon,2665			COLONCOLON => Self::Coloncolon,2666			COLON => Self::Colon,2667			_ => return None,2668		};2669		Some(res)2670	}2671}2672impl Visibility {2673	pub fn kind(&self) -> VisibilityKind {2674		self.kind2675	}2676}2677impl std::fmt::Display for Visibility {2678	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2679		std::fmt::Display::fmt(self.syntax(), f)2680	}2681}2682impl AstToken for Trivia {2683	fn can_cast(kind: SyntaxKind) -> bool {2684		TriviaKind::can_cast(kind)2685	}2686	fn cast(syntax: SyntaxToken) -> Option<Self> {2687		let kind = TriviaKind::cast(syntax.kind())?;2688		Some(Trivia { syntax, kind })2689	}2690	fn syntax(&self) -> &SyntaxToken {2691		&self.syntax2692	}2693}2694impl TriviaKind {2695	fn can_cast(kind: SyntaxKind) -> bool {2696		match kind {2697			WHITESPACE2698			| MULTI_LINE_COMMENT2699			| ERROR_COMMENT_TOO_SHORT2700			| ERROR_COMMENT_UNTERMINATED2701			| SINGLE_LINE_HASH_COMMENT2702			| SINGLE_LINE_SLASH_COMMENT => true,2703			_ => false,2704		}2705	}2706	pub fn cast(kind: SyntaxKind) -> Option<Self> {2707		let res = match kind {2708			WHITESPACE => Self::Whitespace,2709			MULTI_LINE_COMMENT => Self::MultiLineComment,2710			ERROR_COMMENT_TOO_SHORT => Self::ErrorCommentTooShort,2711			ERROR_COMMENT_UNTERMINATED => Self::ErrorCommentUnterminated,2712			SINGLE_LINE_HASH_COMMENT => Self::SingleLineHashComment,2713			SINGLE_LINE_SLASH_COMMENT => Self::SingleLineSlashComment,2714			_ => return None,2715		};2716		Some(res)2717	}2718}2719impl Trivia {2720	pub fn kind(&self) -> TriviaKind {2721		self.kind2722	}2723}2724impl std::fmt::Display for Trivia {2725	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2726		std::fmt::Display::fmt(self.syntax(), f)2727	}2728}2729impl AstToken for CustomError {2730	fn can_cast(kind: SyntaxKind) -> bool {2731		CustomErrorKind::can_cast(kind)2732	}2733	fn cast(syntax: SyntaxToken) -> Option<Self> {2734		let kind = CustomErrorKind::cast(syntax.kind())?;2735		Some(CustomError { syntax, kind })2736	}2737	fn syntax(&self) -> &SyntaxToken {2738		&self.syntax2739	}2740}2741impl CustomErrorKind {2742	fn can_cast(kind: SyntaxKind) -> bool {2743		match kind {2744			ERROR_MISSING_TOKEN | ERROR_UNEXPECTED_TOKEN | ERROR_CUSTOM => true,2745			_ => false,2746		}2747	}2748	pub fn cast(kind: SyntaxKind) -> Option<Self> {2749		let res = match kind {2750			ERROR_MISSING_TOKEN => Self::ErrorMissingToken,2751			ERROR_UNEXPECTED_TOKEN => Self::ErrorUnexpectedToken,2752			ERROR_CUSTOM => Self::ErrorCustom,2753			_ => return None,2754		};2755		Some(res)2756	}2757}2758impl CustomError {2759	pub fn kind(&self) -> CustomErrorKind {2760		self.kind2761	}2762}2763impl std::fmt::Display for CustomError {2764	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2765		std::fmt::Display::fmt(self.syntax(), f)2766	}2767}2768impl std::fmt::Display for Suffix {2769	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2770		std::fmt::Display::fmt(self.syntax(), f)2771	}2772}2773impl std::fmt::Display for Bind {2774	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2775		std::fmt::Display::fmt(self.syntax(), f)2776	}2777}2778impl std::fmt::Display for Stmt {2779	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2780		std::fmt::Display::fmt(self.syntax(), f)2781	}2782}2783impl std::fmt::Display for ObjBody {2784	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2785		std::fmt::Display::fmt(self.syntax(), f)2786	}2787}2788impl std::fmt::Display for CompSpec {2789	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2790		std::fmt::Display::fmt(self.syntax(), f)2791	}2792}2793impl std::fmt::Display for ExprBase {2794	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2795		std::fmt::Display::fmt(self.syntax(), f)2796	}2797}2798impl std::fmt::Display for MemberComp {2799	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2800		std::fmt::Display::fmt(self.syntax(), f)2801	}2802}2803impl std::fmt::Display for Member {2804	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2805		std::fmt::Display::fmt(self.syntax(), f)2806	}2807}2808impl std::fmt::Display for FieldName {2809	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2810		std::fmt::Display::fmt(self.syntax(), f)2811	}2812}2813impl std::fmt::Display for Destruct {2814	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2815		std::fmt::Display::fmt(self.syntax(), f)2816	}2817}2818impl std::fmt::Display for DestructArrayPart {2819	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2820		std::fmt::Display::fmt(self.syntax(), f)2821	}2822}2823impl std::fmt::Display for SourceFile {2824	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2825		std::fmt::Display::fmt(self.syntax(), f)2826	}2827}2828impl std::fmt::Display for Expr {2829	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2830		std::fmt::Display::fmt(self.syntax(), f)2831	}2832}2833impl std::fmt::Display for SuffixIndex {2834	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2835		std::fmt::Display::fmt(self.syntax(), f)2836	}2837}2838impl std::fmt::Display for Name {2839	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2840		std::fmt::Display::fmt(self.syntax(), f)2841	}2842}2843impl std::fmt::Display for SuffixIndexExpr {2844	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2845		std::fmt::Display::fmt(self.syntax(), f)2846	}2847}2848impl std::fmt::Display for SuffixSlice {2849	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2850		std::fmt::Display::fmt(self.syntax(), f)2851	}2852}2853impl std::fmt::Display for SliceDesc {2854	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2855		std::fmt::Display::fmt(self.syntax(), f)2856	}2857}2858impl std::fmt::Display for SuffixApply {2859	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2860		std::fmt::Display::fmt(self.syntax(), f)2861	}2862}2863impl std::fmt::Display for ArgsDesc {2864	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2865		std::fmt::Display::fmt(self.syntax(), f)2866	}2867}2868impl std::fmt::Display for StmtLocal {2869	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2870		std::fmt::Display::fmt(self.syntax(), f)2871	}2872}2873impl std::fmt::Display for StmtAssert {2874	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2875		std::fmt::Display::fmt(self.syntax(), f)2876	}2877}2878impl std::fmt::Display for Assertion {2879	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2880		std::fmt::Display::fmt(self.syntax(), f)2881	}2882}2883impl std::fmt::Display for ExprBinary {2884	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2885		std::fmt::Display::fmt(self.syntax(), f)2886	}2887}2888impl std::fmt::Display for ExprUnary {2889	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2890		std::fmt::Display::fmt(self.syntax(), f)2891	}2892}2893impl std::fmt::Display for ExprObjExtend {2894	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2895		std::fmt::Display::fmt(self.syntax(), f)2896	}2897}2898impl std::fmt::Display for ExprParened {2899	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2900		std::fmt::Display::fmt(self.syntax(), f)2901	}2902}2903impl std::fmt::Display for ExprLiteral {2904	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2905		std::fmt::Display::fmt(self.syntax(), f)2906	}2907}2908impl std::fmt::Display for ExprString {2909	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2910		std::fmt::Display::fmt(self.syntax(), f)2911	}2912}2913impl std::fmt::Display for ExprNumber {2914	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2915		std::fmt::Display::fmt(self.syntax(), f)2916	}2917}2918impl std::fmt::Display for ExprArray {2919	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2920		std::fmt::Display::fmt(self.syntax(), f)2921	}2922}2923impl std::fmt::Display for ExprObject {2924	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2925		std::fmt::Display::fmt(self.syntax(), f)2926	}2927}2928impl std::fmt::Display for ExprArrayComp {2929	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2930		std::fmt::Display::fmt(self.syntax(), f)2931	}2932}2933impl std::fmt::Display for ExprImport {2934	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2935		std::fmt::Display::fmt(self.syntax(), f)2936	}2937}2938impl std::fmt::Display for ExprVar {2939	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2940		std::fmt::Display::fmt(self.syntax(), f)2941	}2942}2943impl std::fmt::Display for ExprIfThenElse {2944	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2945		std::fmt::Display::fmt(self.syntax(), f)2946	}2947}2948impl std::fmt::Display for TrueExpr {2949	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2950		std::fmt::Display::fmt(self.syntax(), f)2951	}2952}2953impl std::fmt::Display for FalseExpr {2954	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2955		std::fmt::Display::fmt(self.syntax(), f)2956	}2957}2958impl std::fmt::Display for ExprFunction {2959	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2960		std::fmt::Display::fmt(self.syntax(), f)2961	}2962}2963impl std::fmt::Display for ParamsDesc {2964	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2965		std::fmt::Display::fmt(self.syntax(), f)2966	}2967}2968impl std::fmt::Display for ExprError {2969	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2970		std::fmt::Display::fmt(self.syntax(), f)2971	}2972}2973impl std::fmt::Display for SliceDescEnd {2974	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2975		std::fmt::Display::fmt(self.syntax(), f)2976	}2977}2978impl std::fmt::Display for SliceDescStep {2979	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2980		std::fmt::Display::fmt(self.syntax(), f)2981	}2982}2983impl std::fmt::Display for Arg {2984	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2985		std::fmt::Display::fmt(self.syntax(), f)2986	}2987}2988impl std::fmt::Display for ObjBodyComp {2989	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2990		std::fmt::Display::fmt(self.syntax(), f)2991	}2992}2993impl std::fmt::Display for ObjBodyMemberList {2994	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2995		std::fmt::Display::fmt(self.syntax(), f)2996	}2997}2998impl std::fmt::Display for MemberBindStmt {2999	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3000		std::fmt::Display::fmt(self.syntax(), f)3001	}3002}3003impl std::fmt::Display for ObjLocal {3004	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3005		std::fmt::Display::fmt(self.syntax(), f)3006	}3007}3008impl std::fmt::Display for MemberAssertStmt {3009	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3010		std::fmt::Display::fmt(self.syntax(), f)3011	}3012}3013impl std::fmt::Display for MemberFieldNormal {3014	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3015		std::fmt::Display::fmt(self.syntax(), f)3016	}3017}3018impl std::fmt::Display for MemberFieldMethod {3019	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3020		std::fmt::Display::fmt(self.syntax(), f)3021	}3022}3023impl std::fmt::Display for FieldNameFixed {3024	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3025		std::fmt::Display::fmt(self.syntax(), f)3026	}3027}3028impl std::fmt::Display for FieldNameDynamic {3029	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3030		std::fmt::Display::fmt(self.syntax(), f)3031	}3032}3033impl std::fmt::Display for ForSpec {3034	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3035		std::fmt::Display::fmt(self.syntax(), f)3036	}3037}3038impl std::fmt::Display for IfSpec {3039	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3040		std::fmt::Display::fmt(self.syntax(), f)3041	}3042}3043impl std::fmt::Display for BindDestruct {3044	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3045		std::fmt::Display::fmt(self.syntax(), f)3046	}3047}3048impl std::fmt::Display for BindFunction {3049	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3050		std::fmt::Display::fmt(self.syntax(), f)3051	}3052}3053impl std::fmt::Display for Param {3054	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3055		std::fmt::Display::fmt(self.syntax(), f)3056	}3057}3058impl std::fmt::Display for DestructFull {3059	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3060		std::fmt::Display::fmt(self.syntax(), f)3061	}3062}3063impl std::fmt::Display for DestructSkip {3064	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3065		std::fmt::Display::fmt(self.syntax(), f)3066	}3067}3068impl std::fmt::Display for DestructArray {3069	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3070		std::fmt::Display::fmt(self.syntax(), f)3071	}3072}3073impl std::fmt::Display for DestructObject {3074	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3075		std::fmt::Display::fmt(self.syntax(), f)3076	}3077}3078impl std::fmt::Display for DestructObjectField {3079	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3080		std::fmt::Display::fmt(self.syntax(), f)3081	}3082}3083impl std::fmt::Display for DestructRest {3084	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3085		std::fmt::Display::fmt(self.syntax(), f)3086	}3087}3088impl std::fmt::Display for DestructArrayElement {3089	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3090		std::fmt::Display::fmt(self.syntax(), f)3091	}3092}