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

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 ExprString {216	pub(crate) syntax: SyntaxNode,217}218impl ExprString {219	pub fn text(&self) -> Option<Text> {220		support::token_child(&self.syntax)221	}222}223224#[derive(Debug, Clone, PartialEq, Eq, Hash)]225pub struct ExprNumber {226	pub(crate) syntax: SyntaxNode,227}228impl ExprNumber {229	pub fn number(&self) -> Option<Number> {230		support::token_child(&self.syntax)231	}232}233234#[derive(Debug, Clone, PartialEq, Eq, Hash)]235pub struct ExprArray {236	pub(crate) syntax: SyntaxNode,237}238impl ExprArray {239	pub fn l_brack_token(&self) -> Option<SyntaxToken> {240		support::token(&self.syntax, T!['['])241	}242	pub fn exprs(&self) -> AstChildren<Expr> {243		support::children(&self.syntax)244	}245	pub fn r_brack_token(&self) -> Option<SyntaxToken> {246		support::token(&self.syntax, T![']'])247	}248}249250#[derive(Debug, Clone, PartialEq, Eq, Hash)]251pub struct ExprObject {252	pub(crate) syntax: SyntaxNode,253}254impl ExprObject {255	pub fn obj_body(&self) -> Option<ObjBody> {256		support::child(&self.syntax)257	}258}259260#[derive(Debug, Clone, PartialEq, Eq, Hash)]261pub struct ExprArrayComp {262	pub(crate) syntax: SyntaxNode,263}264impl ExprArrayComp {265	pub fn l_brack_token(&self) -> Option<SyntaxToken> {266		support::token(&self.syntax, T!['['])267	}268	pub fn expr(&self) -> Option<Expr> {269		support::child(&self.syntax)270	}271	pub fn comma_token(&self) -> Option<SyntaxToken> {272		support::token(&self.syntax, T![,])273	}274	pub fn comp_specs(&self) -> AstChildren<CompSpec> {275		support::children(&self.syntax)276	}277	pub fn r_brack_token(&self) -> Option<SyntaxToken> {278		support::token(&self.syntax, T![']'])279	}280}281282#[derive(Debug, Clone, PartialEq, Eq, Hash)]283pub struct ExprImport {284	pub(crate) syntax: SyntaxNode,285}286impl ExprImport {287	pub fn import_kind(&self) -> Option<ImportKind> {288		support::token_child(&self.syntax)289	}290	pub fn text(&self) -> Option<Text> {291		support::token_child(&self.syntax)292	}293}294295#[derive(Debug, Clone, PartialEq, Eq, Hash)]296pub struct ExprVar {297	pub(crate) syntax: SyntaxNode,298}299impl ExprVar {300	pub fn name(&self) -> Option<Name> {301		support::child(&self.syntax)302	}303}304305#[derive(Debug, Clone, PartialEq, Eq, Hash)]306pub struct ExprLocal {307	pub(crate) syntax: SyntaxNode,308}309impl ExprLocal {310	pub fn local_kw_token(&self) -> Option<SyntaxToken> {311		support::token(&self.syntax, T![local])312	}313	pub fn binds(&self) -> AstChildren<Bind> {314		support::children(&self.syntax)315	}316	pub fn semi_token(&self) -> Option<SyntaxToken> {317		support::token(&self.syntax, T![;])318	}319	pub fn expr(&self) -> Option<Expr> {320		support::child(&self.syntax)321	}322}323324#[derive(Debug, Clone, PartialEq, Eq, Hash)]325pub struct ExprIfThenElse {326	pub(crate) syntax: SyntaxNode,327}328impl ExprIfThenElse {329	pub fn if_kw_token(&self) -> Option<SyntaxToken> {330		support::token(&self.syntax, T![if])331	}332	pub fn cond(&self) -> Option<Expr> {333		support::child(&self.syntax)334	}335	pub fn then_kw_token(&self) -> Option<SyntaxToken> {336		support::token(&self.syntax, T![then])337	}338	pub fn then(&self) -> Option<TrueExpr> {339		support::child(&self.syntax)340	}341	pub fn else_kw_token(&self) -> Option<SyntaxToken> {342		support::token(&self.syntax, T![else])343	}344	pub fn else_(&self) -> Option<FalseExpr> {345		support::child(&self.syntax)346	}347}348349#[derive(Debug, Clone, PartialEq, Eq, Hash)]350pub struct TrueExpr {351	pub(crate) syntax: SyntaxNode,352}353impl TrueExpr {354	pub fn expr(&self) -> Option<Expr> {355		support::child(&self.syntax)356	}357}358359#[derive(Debug, Clone, PartialEq, Eq, Hash)]360pub struct FalseExpr {361	pub(crate) syntax: SyntaxNode,362}363impl FalseExpr {364	pub fn expr(&self) -> Option<Expr> {365		support::child(&self.syntax)366	}367}368369#[derive(Debug, Clone, PartialEq, Eq, Hash)]370pub struct ExprFunction {371	pub(crate) syntax: SyntaxNode,372}373impl ExprFunction {374	pub fn function_kw_token(&self) -> Option<SyntaxToken> {375		support::token(&self.syntax, T![function])376	}377	pub fn l_paren_token(&self) -> Option<SyntaxToken> {378		support::token(&self.syntax, T!['('])379	}380	pub fn params_desc(&self) -> Option<ParamsDesc> {381		support::child(&self.syntax)382	}383	pub fn r_paren_token(&self) -> Option<SyntaxToken> {384		support::token(&self.syntax, T![')'])385	}386	pub fn expr(&self) -> Option<Expr> {387		support::child(&self.syntax)388	}389}390391#[derive(Debug, Clone, PartialEq, Eq, Hash)]392pub struct ParamsDesc {393	pub(crate) syntax: SyntaxNode,394}395impl ParamsDesc {396	pub fn l_paren_token(&self) -> Option<SyntaxToken> {397		support::token(&self.syntax, T!['('])398	}399	pub fn params(&self) -> AstChildren<Param> {400		support::children(&self.syntax)401	}402	pub fn r_paren_token(&self) -> Option<SyntaxToken> {403		support::token(&self.syntax, T![')'])404	}405}406407#[derive(Debug, Clone, PartialEq, Eq, Hash)]408pub struct ExprAssert {409	pub(crate) syntax: SyntaxNode,410}411impl ExprAssert {412	pub fn assertion(&self) -> Option<Assertion> {413		support::child(&self.syntax)414	}415	pub fn semi_token(&self) -> Option<SyntaxToken> {416		support::token(&self.syntax, T![;])417	}418	pub fn expr(&self) -> Option<Expr> {419		support::child(&self.syntax)420	}421}422423#[derive(Debug, Clone, PartialEq, Eq, Hash)]424pub struct Assertion {425	pub(crate) syntax: SyntaxNode,426}427impl Assertion {428	pub fn assert_kw_token(&self) -> Option<SyntaxToken> {429		support::token(&self.syntax, T![assert])430	}431	pub fn condition(&self) -> Option<LhsExpr> {432		support::child(&self.syntax)433	}434	pub fn colon_token(&self) -> Option<SyntaxToken> {435		support::token(&self.syntax, T![:])436	}437	pub fn message(&self) -> Option<Expr> {438		support::child(&self.syntax)439	}440}441442#[derive(Debug, Clone, PartialEq, Eq, Hash)]443pub struct ExprError {444	pub(crate) syntax: SyntaxNode,445}446impl ExprError {447	pub fn error_kw_token(&self) -> Option<SyntaxToken> {448		support::token(&self.syntax, T![error])449	}450	pub fn expr(&self) -> Option<Expr> {451		support::child(&self.syntax)452	}453}454455#[derive(Debug, Clone, PartialEq, Eq, Hash)]456pub struct SliceDescEnd {457	pub(crate) syntax: SyntaxNode,458}459impl SliceDescEnd {460	pub fn expr(&self) -> Option<Expr> {461		support::child(&self.syntax)462	}463}464465#[derive(Debug, Clone, PartialEq, Eq, Hash)]466pub struct SliceDescStep {467	pub(crate) syntax: SyntaxNode,468}469impl SliceDescStep {470	pub fn expr(&self) -> Option<Expr> {471		support::child(&self.syntax)472	}473}474475#[derive(Debug, Clone, PartialEq, Eq, Hash)]476pub struct Arg {477	pub(crate) syntax: SyntaxNode,478}479impl Arg {480	pub fn name(&self) -> Option<Name> {481		support::child(&self.syntax)482	}483	pub fn assign_token(&self) -> Option<SyntaxToken> {484		support::token(&self.syntax, T![=])485	}486	pub fn expr(&self) -> Option<Expr> {487		support::child(&self.syntax)488	}489}490491#[derive(Debug, Clone, PartialEq, Eq, Hash)]492pub struct ObjBodyComp {493	pub(crate) syntax: SyntaxNode,494}495impl ObjBodyComp {496	pub fn l_brace_token(&self) -> Option<SyntaxToken> {497		support::token(&self.syntax, T!['{'])498	}499	pub fn member_comps(&self) -> AstChildren<MemberComp> {500		support::children(&self.syntax)501	}502	pub fn comp_specs(&self) -> AstChildren<CompSpec> {503		support::children(&self.syntax)504	}505	pub fn r_brace_token(&self) -> Option<SyntaxToken> {506		support::token(&self.syntax, T!['}'])507	}508}509510#[derive(Debug, Clone, PartialEq, Eq, Hash)]511pub struct ObjBodyMemberList {512	pub(crate) syntax: SyntaxNode,513}514impl ObjBodyMemberList {515	pub fn l_brace_token(&self) -> Option<SyntaxToken> {516		support::token(&self.syntax, T!['{'])517	}518	pub fn members(&self) -> AstChildren<Member> {519		support::children(&self.syntax)520	}521	pub fn r_brace_token(&self) -> Option<SyntaxToken> {522		support::token(&self.syntax, T!['}'])523	}524}525526#[derive(Debug, Clone, PartialEq, Eq, Hash)]527pub struct MemberBindStmt {528	pub(crate) syntax: SyntaxNode,529}530impl MemberBindStmt {531	pub fn obj_local(&self) -> Option<ObjLocal> {532		support::child(&self.syntax)533	}534}535536#[derive(Debug, Clone, PartialEq, Eq, Hash)]537pub struct ObjLocal {538	pub(crate) syntax: SyntaxNode,539}540impl ObjLocal {541	pub fn local_kw_token(&self) -> Option<SyntaxToken> {542		support::token(&self.syntax, T![local])543	}544	pub fn bind(&self) -> Option<Bind> {545		support::child(&self.syntax)546	}547}548549#[derive(Debug, Clone, PartialEq, Eq, Hash)]550pub struct MemberAssertStmt {551	pub(crate) syntax: SyntaxNode,552}553impl MemberAssertStmt {554	pub fn assertion(&self) -> Option<Assertion> {555		support::child(&self.syntax)556	}557}558559#[derive(Debug, Clone, PartialEq, Eq, Hash)]560pub struct MemberFieldNormal {561	pub(crate) syntax: SyntaxNode,562}563impl MemberFieldNormal {564	pub fn field_name(&self) -> Option<FieldName> {565		support::child(&self.syntax)566	}567	pub fn plus_token(&self) -> Option<SyntaxToken> {568		support::token(&self.syntax, T![+])569	}570	pub fn visibility(&self) -> Option<Visibility> {571		support::token_child(&self.syntax)572	}573	pub fn expr(&self) -> Option<Expr> {574		support::child(&self.syntax)575	}576}577578#[derive(Debug, Clone, PartialEq, Eq, Hash)]579pub struct MemberFieldMethod {580	pub(crate) syntax: SyntaxNode,581}582impl MemberFieldMethod {583	pub fn field_name(&self) -> Option<FieldName> {584		support::child(&self.syntax)585	}586	pub fn params_desc(&self) -> Option<ParamsDesc> {587		support::child(&self.syntax)588	}589	pub fn visibility(&self) -> Option<Visibility> {590		support::token_child(&self.syntax)591	}592	pub fn expr(&self) -> Option<Expr> {593		support::child(&self.syntax)594	}595}596597#[derive(Debug, Clone, PartialEq, Eq, Hash)]598pub struct FieldNameFixed {599	pub(crate) syntax: SyntaxNode,600}601impl FieldNameFixed {602	pub fn id(&self) -> Option<Name> {603		support::child(&self.syntax)604	}605	pub fn text(&self) -> Option<Text> {606		support::token_child(&self.syntax)607	}608}609610#[derive(Debug, Clone, PartialEq, Eq, Hash)]611pub struct FieldNameDynamic {612	pub(crate) syntax: SyntaxNode,613}614impl FieldNameDynamic {615	pub fn l_brack_token(&self) -> Option<SyntaxToken> {616		support::token(&self.syntax, T!['['])617	}618	pub fn expr(&self) -> Option<Expr> {619		support::child(&self.syntax)620	}621	pub fn r_brack_token(&self) -> Option<SyntaxToken> {622		support::token(&self.syntax, T![']'])623	}624}625626#[derive(Debug, Clone, PartialEq, Eq, Hash)]627pub struct ForSpec {628	pub(crate) syntax: SyntaxNode,629}630impl ForSpec {631	pub fn for_kw_token(&self) -> Option<SyntaxToken> {632		support::token(&self.syntax, T![for])633	}634	pub fn bind(&self) -> Option<Name> {635		support::child(&self.syntax)636	}637	pub fn in_kw_token(&self) -> Option<SyntaxToken> {638		support::token(&self.syntax, T![in])639	}640	pub fn expr(&self) -> Option<Expr> {641		support::child(&self.syntax)642	}643}644645#[derive(Debug, Clone, PartialEq, Eq, Hash)]646pub struct IfSpec {647	pub(crate) syntax: SyntaxNode,648}649impl IfSpec {650	pub fn if_kw_token(&self) -> Option<SyntaxToken> {651		support::token(&self.syntax, T![if])652	}653	pub fn expr(&self) -> Option<Expr> {654		support::child(&self.syntax)655	}656}657658#[derive(Debug, Clone, PartialEq, Eq, Hash)]659pub struct BindDestruct {660	pub(crate) syntax: SyntaxNode,661}662impl BindDestruct {663	pub fn into(&self) -> Option<Destruct> {664		support::child(&self.syntax)665	}666	pub fn assign_token(&self) -> Option<SyntaxToken> {667		support::token(&self.syntax, T![=])668	}669	pub fn value(&self) -> Option<Expr> {670		support::child(&self.syntax)671	}672}673674#[derive(Debug, Clone, PartialEq, Eq, Hash)]675pub struct BindFunction {676	pub(crate) syntax: SyntaxNode,677}678impl BindFunction {679	pub fn name(&self) -> Option<Name> {680		support::child(&self.syntax)681	}682	pub fn params(&self) -> Option<ParamsDesc> {683		support::child(&self.syntax)684	}685	pub fn assign_token(&self) -> Option<SyntaxToken> {686		support::token(&self.syntax, T![=])687	}688	pub fn value(&self) -> Option<Expr> {689		support::child(&self.syntax)690	}691}692693#[derive(Debug, Clone, PartialEq, Eq, Hash)]694pub struct Param {695	pub(crate) syntax: SyntaxNode,696}697impl Param {698	pub fn destruct(&self) -> Option<Destruct> {699		support::child(&self.syntax)700	}701	pub fn assign_token(&self) -> Option<SyntaxToken> {702		support::token(&self.syntax, T![=])703	}704	pub fn expr(&self) -> Option<Expr> {705		support::child(&self.syntax)706	}707}708709#[derive(Debug, Clone, PartialEq, Eq, Hash)]710pub struct DestructFull {711	pub(crate) syntax: SyntaxNode,712}713impl DestructFull {714	pub fn name(&self) -> Option<Name> {715		support::child(&self.syntax)716	}717}718719#[derive(Debug, Clone, PartialEq, Eq, Hash)]720pub struct DestructSkip {721	pub(crate) syntax: SyntaxNode,722}723impl DestructSkip {724	pub fn question_mark_token(&self) -> Option<SyntaxToken> {725		support::token(&self.syntax, T![?])726	}727}728729#[derive(Debug, Clone, PartialEq, Eq, Hash)]730pub struct DestructArray {731	pub(crate) syntax: SyntaxNode,732}733impl DestructArray {734	pub fn l_brack_token(&self) -> Option<SyntaxToken> {735		support::token(&self.syntax, T!['['])736	}737	pub fn destruct_array_parts(&self) -> AstChildren<DestructArrayPart> {738		support::children(&self.syntax)739	}740	pub fn r_brack_token(&self) -> Option<SyntaxToken> {741		support::token(&self.syntax, T![']'])742	}743}744745#[derive(Debug, Clone, PartialEq, Eq, Hash)]746pub struct DestructObject {747	pub(crate) syntax: SyntaxNode,748}749impl DestructObject {750	pub fn l_brace_token(&self) -> Option<SyntaxToken> {751		support::token(&self.syntax, T!['{'])752	}753	pub fn destruct_object_fields(&self) -> AstChildren<DestructObjectField> {754		support::children(&self.syntax)755	}756	pub fn destruct_rest(&self) -> Option<DestructRest> {757		support::child(&self.syntax)758	}759	pub fn comma_token(&self) -> Option<SyntaxToken> {760		support::token(&self.syntax, T![,])761	}762	pub fn r_brace_token(&self) -> Option<SyntaxToken> {763		support::token(&self.syntax, T!['}'])764	}765}766767#[derive(Debug, Clone, PartialEq, Eq, Hash)]768pub struct DestructObjectField {769	pub(crate) syntax: SyntaxNode,770}771impl DestructObjectField {772	pub fn field(&self) -> Option<Name> {773		support::child(&self.syntax)774	}775	pub fn colon_token(&self) -> Option<SyntaxToken> {776		support::token(&self.syntax, T![:])777	}778	pub fn destruct(&self) -> Option<Destruct> {779		support::child(&self.syntax)780	}781	pub fn assign_token(&self) -> Option<SyntaxToken> {782		support::token(&self.syntax, T![=])783	}784	pub fn expr(&self) -> Option<Expr> {785		support::child(&self.syntax)786	}787}788789#[derive(Debug, Clone, PartialEq, Eq, Hash)]790pub struct DestructRest {791	pub(crate) syntax: SyntaxNode,792}793impl DestructRest {794	pub fn dotdotdot_token(&self) -> Option<SyntaxToken> {795		support::token(&self.syntax, T![...])796	}797	pub fn into(&self) -> Option<Name> {798		support::child(&self.syntax)799	}800}801802#[derive(Debug, Clone, PartialEq, Eq, Hash)]803pub struct DestructArrayElement {804	pub(crate) syntax: SyntaxNode,805}806impl DestructArrayElement {807	pub fn destruct(&self) -> Option<Destruct> {808		support::child(&self.syntax)809	}810}811812#[derive(Debug, Clone, PartialEq, Eq, Hash)]813pub enum Expr {814	ExprBinary(ExprBinary),815	ExprUnary(ExprUnary),816	ExprSlice(ExprSlice),817	ExprIndex(ExprIndex),818	ExprIndexExpr(ExprIndexExpr),819	ExprApply(ExprApply),820	ExprObjExtend(ExprObjExtend),821	ExprParened(ExprParened),822	ExprString(ExprString),823	ExprNumber(ExprNumber),824	ExprLiteral(ExprLiteral),825	ExprArray(ExprArray),826	ExprObject(ExprObject),827	ExprArrayComp(ExprArrayComp),828	ExprImport(ExprImport),829	ExprVar(ExprVar),830	ExprLocal(ExprLocal),831	ExprIfThenElse(ExprIfThenElse),832	ExprFunction(ExprFunction),833	ExprAssert(ExprAssert),834	ExprError(ExprError),835}836837#[derive(Debug, Clone, PartialEq, Eq, Hash)]838pub enum ObjBody {839	ObjBodyComp(ObjBodyComp),840	ObjBodyMemberList(ObjBodyMemberList),841}842843#[derive(Debug, Clone, PartialEq, Eq, Hash)]844pub enum CompSpec {845	ForSpec(ForSpec),846	IfSpec(IfSpec),847}848849#[derive(Debug, Clone, PartialEq, Eq, Hash)]850pub enum Bind {851	BindDestruct(BindDestruct),852	BindFunction(BindFunction),853}854855#[derive(Debug, Clone, PartialEq, Eq, Hash)]856pub enum MemberComp {857	MemberBindStmt(MemberBindStmt),858	MemberFieldNormal(MemberFieldNormal),859	MemberFieldMethod(MemberFieldMethod),860}861862#[derive(Debug, Clone, PartialEq, Eq, Hash)]863pub enum Member {864	MemberBindStmt(MemberBindStmt),865	MemberAssertStmt(MemberAssertStmt),866	MemberFieldNormal(MemberFieldNormal),867	MemberFieldMethod(MemberFieldMethod),868}869870#[derive(Debug, Clone, PartialEq, Eq, Hash)]871pub enum FieldName {872	FieldNameFixed(FieldNameFixed),873	FieldNameDynamic(FieldNameDynamic),874}875876#[derive(Debug, Clone, PartialEq, Eq, Hash)]877pub enum Destruct {878	DestructFull(DestructFull),879	DestructSkip(DestructSkip),880	DestructArray(DestructArray),881	DestructObject(DestructObject),882}883884#[derive(Debug, Clone, PartialEq, Eq, Hash)]885pub enum DestructArrayPart {886	DestructArrayElement(DestructArrayElement),887	DestructRest(DestructRest),888}889890#[derive(Debug, Clone, PartialEq, Eq, Hash)]891pub struct BinaryOperator {892	syntax: SyntaxToken,893	kind: BinaryOperatorKind,894}895896#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]897pub enum BinaryOperatorKind {898	Or,899	And,900	BitOr,901	BitXor,902	BitAnd,903	Eq,904	Ne,905	Lt,906	Gt,907	Le,908	Ge,909	InKw,910	Lhs,911	Rhs,912	Plus,913	Minus,914	Mul,915	Div,916	Modulo,917	MetaObjectApply,918	ErrorNoOperator,919}920921#[derive(Debug, Clone, PartialEq, Eq, Hash)]922pub struct UnaryOperator {923	syntax: SyntaxToken,924	kind: UnaryOperatorKind,925}926927#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]928pub enum UnaryOperatorKind {929	Minus,930	Not,931	BitNot,932}933934#[derive(Debug, Clone, PartialEq, Eq, Hash)]935pub struct Literal {936	syntax: SyntaxToken,937	kind: LiteralKind,938}939940#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]941pub enum LiteralKind {942	NullKw,943	TrueKw,944	FalseKw,945	SelfKw,946	Dollar,947	SuperKw,948}949950#[derive(Debug, Clone, PartialEq, Eq, Hash)]951pub struct Text {952	syntax: SyntaxToken,953	kind: TextKind,954}955956#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]957pub enum TextKind {958	StringDouble,959	ErrorStringDoubleUnterminated,960	StringSingle,961	ErrorStringSingleUnterminated,962	StringDoubleVerbatim,963	ErrorStringDoubleVerbatimUnterminated,964	StringSingleVerbatim,965	ErrorStringSingleVerbatimUnterminated,966	ErrorStringVerbatimMissingQuotes,967	StringBlock,968	ErrorStringBlockUnexpectedEnd,969	ErrorStringBlockMissingNewLine,970	ErrorStringBlockMissingTermination,971	ErrorStringBlockMissingIndent,972}973974#[derive(Debug, Clone, PartialEq, Eq, Hash)]975pub struct Number {976	syntax: SyntaxToken,977	kind: NumberKind,978}979980#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]981pub enum NumberKind {982	Float,983	ErrorFloatJunkAfterPoint,984	ErrorFloatJunkAfterExponent,985	ErrorFloatJunkAfterExponentSign,986}987988#[derive(Debug, Clone, PartialEq, Eq, Hash)]989pub struct ImportKind {990	syntax: SyntaxToken,991	kind: ImportKindKind,992}993994#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]995pub enum ImportKindKind {996	ImportstrKw,997	ImportbinKw,998	ImportKw,999}10001001#[derive(Debug, Clone, PartialEq, Eq, Hash)]1002pub struct Visibility {1003	syntax: SyntaxToken,1004	kind: VisibilityKind,1005}10061007#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]1008pub enum VisibilityKind {1009	Coloncoloncolon,1010	Coloncolon,1011	Colon,1012}10131014#[derive(Debug, Clone, PartialEq, Eq, Hash)]1015pub struct Trivia {1016	syntax: SyntaxToken,1017	kind: TriviaKind,1018}10191020#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]1021pub enum TriviaKind {1022	Whitespace,1023	MultiLineComment,1024	ErrorCommentTooShort,1025	ErrorCommentUnterminated,1026	SingleLineHashComment,1027	SingleLineSlashComment,1028}10291030#[derive(Debug, Clone, PartialEq, Eq, Hash)]1031pub struct CustomError {1032	syntax: SyntaxToken,1033	kind: CustomErrorKind,1034}10351036#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]1037pub enum CustomErrorKind {1038	ErrorMissingToken,1039	ErrorUnexpectedToken,1040	ErrorCustom,1041}1042impl AstNode for SourceFile {1043	fn can_cast(kind: SyntaxKind) -> bool {1044		kind == SOURCE_FILE1045	}1046	fn cast(syntax: SyntaxNode) -> Option<Self> {1047		if Self::can_cast(syntax.kind()) {1048			Some(Self { syntax })1049		} else {1050			None1051		}1052	}1053	fn syntax(&self) -> &SyntaxNode {1054		&self.syntax1055	}1056}1057impl AstNode for ExprBinary {1058	fn can_cast(kind: SyntaxKind) -> bool {1059		kind == EXPR_BINARY1060	}1061	fn cast(syntax: SyntaxNode) -> Option<Self> {1062		if Self::can_cast(syntax.kind()) {1063			Some(Self { syntax })1064		} else {1065			None1066		}1067	}1068	fn syntax(&self) -> &SyntaxNode {1069		&self.syntax1070	}1071}1072impl AstNode for LhsExpr {1073	fn can_cast(kind: SyntaxKind) -> bool {1074		kind == LHS_EXPR1075	}1076	fn cast(syntax: SyntaxNode) -> Option<Self> {1077		if Self::can_cast(syntax.kind()) {1078			Some(Self { syntax })1079		} else {1080			None1081		}1082	}1083	fn syntax(&self) -> &SyntaxNode {1084		&self.syntax1085	}1086}1087impl AstNode for ExprUnary {1088	fn can_cast(kind: SyntaxKind) -> bool {1089		kind == EXPR_UNARY1090	}1091	fn cast(syntax: SyntaxNode) -> Option<Self> {1092		if Self::can_cast(syntax.kind()) {1093			Some(Self { syntax })1094		} else {1095			None1096		}1097	}1098	fn syntax(&self) -> &SyntaxNode {1099		&self.syntax1100	}1101}1102impl AstNode for ExprSlice {1103	fn can_cast(kind: SyntaxKind) -> bool {1104		kind == EXPR_SLICE1105	}1106	fn cast(syntax: SyntaxNode) -> Option<Self> {1107		if Self::can_cast(syntax.kind()) {1108			Some(Self { syntax })1109		} else {1110			None1111		}1112	}1113	fn syntax(&self) -> &SyntaxNode {1114		&self.syntax1115	}1116}1117impl AstNode for SliceDesc {1118	fn can_cast(kind: SyntaxKind) -> bool {1119		kind == SLICE_DESC1120	}1121	fn cast(syntax: SyntaxNode) -> Option<Self> {1122		if Self::can_cast(syntax.kind()) {1123			Some(Self { syntax })1124		} else {1125			None1126		}1127	}1128	fn syntax(&self) -> &SyntaxNode {1129		&self.syntax1130	}1131}1132impl AstNode for ExprIndex {1133	fn can_cast(kind: SyntaxKind) -> bool {1134		kind == EXPR_INDEX1135	}1136	fn cast(syntax: SyntaxNode) -> Option<Self> {1137		if Self::can_cast(syntax.kind()) {1138			Some(Self { syntax })1139		} else {1140			None1141		}1142	}1143	fn syntax(&self) -> &SyntaxNode {1144		&self.syntax1145	}1146}1147impl AstNode for Name {1148	fn can_cast(kind: SyntaxKind) -> bool {1149		kind == NAME1150	}1151	fn cast(syntax: SyntaxNode) -> Option<Self> {1152		if Self::can_cast(syntax.kind()) {1153			Some(Self { syntax })1154		} else {1155			None1156		}1157	}1158	fn syntax(&self) -> &SyntaxNode {1159		&self.syntax1160	}1161}1162impl AstNode for ExprIndexExpr {1163	fn can_cast(kind: SyntaxKind) -> bool {1164		kind == EXPR_INDEX_EXPR1165	}1166	fn cast(syntax: SyntaxNode) -> Option<Self> {1167		if Self::can_cast(syntax.kind()) {1168			Some(Self { syntax })1169		} else {1170			None1171		}1172	}1173	fn syntax(&self) -> &SyntaxNode {1174		&self.syntax1175	}1176}1177impl AstNode for ExprApply {1178	fn can_cast(kind: SyntaxKind) -> bool {1179		kind == EXPR_APPLY1180	}1181	fn cast(syntax: SyntaxNode) -> Option<Self> {1182		if Self::can_cast(syntax.kind()) {1183			Some(Self { syntax })1184		} else {1185			None1186		}1187	}1188	fn syntax(&self) -> &SyntaxNode {1189		&self.syntax1190	}1191}1192impl AstNode for ArgsDesc {1193	fn can_cast(kind: SyntaxKind) -> bool {1194		kind == ARGS_DESC1195	}1196	fn cast(syntax: SyntaxNode) -> Option<Self> {1197		if Self::can_cast(syntax.kind()) {1198			Some(Self { syntax })1199		} else {1200			None1201		}1202	}1203	fn syntax(&self) -> &SyntaxNode {1204		&self.syntax1205	}1206}1207impl AstNode for ExprObjExtend {1208	fn can_cast(kind: SyntaxKind) -> bool {1209		kind == EXPR_OBJ_EXTEND1210	}1211	fn cast(syntax: SyntaxNode) -> Option<Self> {1212		if Self::can_cast(syntax.kind()) {1213			Some(Self { syntax })1214		} else {1215			None1216		}1217	}1218	fn syntax(&self) -> &SyntaxNode {1219		&self.syntax1220	}1221}1222impl AstNode for ExprParened {1223	fn can_cast(kind: SyntaxKind) -> bool {1224		kind == EXPR_PARENED1225	}1226	fn cast(syntax: SyntaxNode) -> Option<Self> {1227		if Self::can_cast(syntax.kind()) {1228			Some(Self { syntax })1229		} else {1230			None1231		}1232	}1233	fn syntax(&self) -> &SyntaxNode {1234		&self.syntax1235	}1236}1237impl AstNode for ExprLiteral {1238	fn can_cast(kind: SyntaxKind) -> bool {1239		kind == EXPR_LITERAL1240	}1241	fn cast(syntax: SyntaxNode) -> Option<Self> {1242		if Self::can_cast(syntax.kind()) {1243			Some(Self { syntax })1244		} else {1245			None1246		}1247	}1248	fn syntax(&self) -> &SyntaxNode {1249		&self.syntax1250	}1251}1252impl AstNode for ExprString {1253	fn can_cast(kind: SyntaxKind) -> bool {1254		kind == EXPR_STRING1255	}1256	fn cast(syntax: SyntaxNode) -> Option<Self> {1257		if Self::can_cast(syntax.kind()) {1258			Some(Self { syntax })1259		} else {1260			None1261		}1262	}1263	fn syntax(&self) -> &SyntaxNode {1264		&self.syntax1265	}1266}1267impl AstNode for ExprNumber {1268	fn can_cast(kind: SyntaxKind) -> bool {1269		kind == EXPR_NUMBER1270	}1271	fn cast(syntax: SyntaxNode) -> Option<Self> {1272		if Self::can_cast(syntax.kind()) {1273			Some(Self { syntax })1274		} else {1275			None1276		}1277	}1278	fn syntax(&self) -> &SyntaxNode {1279		&self.syntax1280	}1281}1282impl AstNode for ExprArray {1283	fn can_cast(kind: SyntaxKind) -> bool {1284		kind == EXPR_ARRAY1285	}1286	fn cast(syntax: SyntaxNode) -> Option<Self> {1287		if Self::can_cast(syntax.kind()) {1288			Some(Self { syntax })1289		} else {1290			None1291		}1292	}1293	fn syntax(&self) -> &SyntaxNode {1294		&self.syntax1295	}1296}1297impl AstNode for ExprObject {1298	fn can_cast(kind: SyntaxKind) -> bool {1299		kind == EXPR_OBJECT1300	}1301	fn cast(syntax: SyntaxNode) -> Option<Self> {1302		if Self::can_cast(syntax.kind()) {1303			Some(Self { syntax })1304		} else {1305			None1306		}1307	}1308	fn syntax(&self) -> &SyntaxNode {1309		&self.syntax1310	}1311}1312impl AstNode for ExprArrayComp {1313	fn can_cast(kind: SyntaxKind) -> bool {1314		kind == EXPR_ARRAY_COMP1315	}1316	fn cast(syntax: SyntaxNode) -> Option<Self> {1317		if Self::can_cast(syntax.kind()) {1318			Some(Self { syntax })1319		} else {1320			None1321		}1322	}1323	fn syntax(&self) -> &SyntaxNode {1324		&self.syntax1325	}1326}1327impl AstNode for ExprImport {1328	fn can_cast(kind: SyntaxKind) -> bool {1329		kind == EXPR_IMPORT1330	}1331	fn cast(syntax: SyntaxNode) -> Option<Self> {1332		if Self::can_cast(syntax.kind()) {1333			Some(Self { syntax })1334		} else {1335			None1336		}1337	}1338	fn syntax(&self) -> &SyntaxNode {1339		&self.syntax1340	}1341}1342impl AstNode for ExprVar {1343	fn can_cast(kind: SyntaxKind) -> bool {1344		kind == EXPR_VAR1345	}1346	fn cast(syntax: SyntaxNode) -> Option<Self> {1347		if Self::can_cast(syntax.kind()) {1348			Some(Self { syntax })1349		} else {1350			None1351		}1352	}1353	fn syntax(&self) -> &SyntaxNode {1354		&self.syntax1355	}1356}1357impl AstNode for ExprLocal {1358	fn can_cast(kind: SyntaxKind) -> bool {1359		kind == EXPR_LOCAL1360	}1361	fn cast(syntax: SyntaxNode) -> Option<Self> {1362		if Self::can_cast(syntax.kind()) {1363			Some(Self { syntax })1364		} else {1365			None1366		}1367	}1368	fn syntax(&self) -> &SyntaxNode {1369		&self.syntax1370	}1371}1372impl AstNode for ExprIfThenElse {1373	fn can_cast(kind: SyntaxKind) -> bool {1374		kind == EXPR_IF_THEN_ELSE1375	}1376	fn cast(syntax: SyntaxNode) -> Option<Self> {1377		if Self::can_cast(syntax.kind()) {1378			Some(Self { syntax })1379		} else {1380			None1381		}1382	}1383	fn syntax(&self) -> &SyntaxNode {1384		&self.syntax1385	}1386}1387impl AstNode for TrueExpr {1388	fn can_cast(kind: SyntaxKind) -> bool {1389		kind == TRUE_EXPR1390	}1391	fn cast(syntax: SyntaxNode) -> Option<Self> {1392		if Self::can_cast(syntax.kind()) {1393			Some(Self { syntax })1394		} else {1395			None1396		}1397	}1398	fn syntax(&self) -> &SyntaxNode {1399		&self.syntax1400	}1401}1402impl AstNode for FalseExpr {1403	fn can_cast(kind: SyntaxKind) -> bool {1404		kind == FALSE_EXPR1405	}1406	fn cast(syntax: SyntaxNode) -> Option<Self> {1407		if Self::can_cast(syntax.kind()) {1408			Some(Self { syntax })1409		} else {1410			None1411		}1412	}1413	fn syntax(&self) -> &SyntaxNode {1414		&self.syntax1415	}1416}1417impl AstNode for ExprFunction {1418	fn can_cast(kind: SyntaxKind) -> bool {1419		kind == EXPR_FUNCTION1420	}1421	fn cast(syntax: SyntaxNode) -> Option<Self> {1422		if Self::can_cast(syntax.kind()) {1423			Some(Self { syntax })1424		} else {1425			None1426		}1427	}1428	fn syntax(&self) -> &SyntaxNode {1429		&self.syntax1430	}1431}1432impl AstNode for ParamsDesc {1433	fn can_cast(kind: SyntaxKind) -> bool {1434		kind == PARAMS_DESC1435	}1436	fn cast(syntax: SyntaxNode) -> Option<Self> {1437		if Self::can_cast(syntax.kind()) {1438			Some(Self { syntax })1439		} else {1440			None1441		}1442	}1443	fn syntax(&self) -> &SyntaxNode {1444		&self.syntax1445	}1446}1447impl AstNode for ExprAssert {1448	fn can_cast(kind: SyntaxKind) -> bool {1449		kind == EXPR_ASSERT1450	}1451	fn cast(syntax: SyntaxNode) -> Option<Self> {1452		if Self::can_cast(syntax.kind()) {1453			Some(Self { syntax })1454		} else {1455			None1456		}1457	}1458	fn syntax(&self) -> &SyntaxNode {1459		&self.syntax1460	}1461}1462impl AstNode for Assertion {1463	fn can_cast(kind: SyntaxKind) -> bool {1464		kind == ASSERTION1465	}1466	fn cast(syntax: SyntaxNode) -> Option<Self> {1467		if Self::can_cast(syntax.kind()) {1468			Some(Self { syntax })1469		} else {1470			None1471		}1472	}1473	fn syntax(&self) -> &SyntaxNode {1474		&self.syntax1475	}1476}1477impl AstNode for ExprError {1478	fn can_cast(kind: SyntaxKind) -> bool {1479		kind == EXPR_ERROR1480	}1481	fn cast(syntax: SyntaxNode) -> Option<Self> {1482		if Self::can_cast(syntax.kind()) {1483			Some(Self { syntax })1484		} else {1485			None1486		}1487	}1488	fn syntax(&self) -> &SyntaxNode {1489		&self.syntax1490	}1491}1492impl AstNode for SliceDescEnd {1493	fn can_cast(kind: SyntaxKind) -> bool {1494		kind == SLICE_DESC_END1495	}1496	fn cast(syntax: SyntaxNode) -> Option<Self> {1497		if Self::can_cast(syntax.kind()) {1498			Some(Self { syntax })1499		} else {1500			None1501		}1502	}1503	fn syntax(&self) -> &SyntaxNode {1504		&self.syntax1505	}1506}1507impl AstNode for SliceDescStep {1508	fn can_cast(kind: SyntaxKind) -> bool {1509		kind == SLICE_DESC_STEP1510	}1511	fn cast(syntax: SyntaxNode) -> Option<Self> {1512		if Self::can_cast(syntax.kind()) {1513			Some(Self { syntax })1514		} else {1515			None1516		}1517	}1518	fn syntax(&self) -> &SyntaxNode {1519		&self.syntax1520	}1521}1522impl AstNode for Arg {1523	fn can_cast(kind: SyntaxKind) -> bool {1524		kind == ARG1525	}1526	fn cast(syntax: SyntaxNode) -> Option<Self> {1527		if Self::can_cast(syntax.kind()) {1528			Some(Self { syntax })1529		} else {1530			None1531		}1532	}1533	fn syntax(&self) -> &SyntaxNode {1534		&self.syntax1535	}1536}1537impl AstNode for ObjBodyComp {1538	fn can_cast(kind: SyntaxKind) -> bool {1539		kind == OBJ_BODY_COMP1540	}1541	fn cast(syntax: SyntaxNode) -> Option<Self> {1542		if Self::can_cast(syntax.kind()) {1543			Some(Self { syntax })1544		} else {1545			None1546		}1547	}1548	fn syntax(&self) -> &SyntaxNode {1549		&self.syntax1550	}1551}1552impl AstNode for ObjBodyMemberList {1553	fn can_cast(kind: SyntaxKind) -> bool {1554		kind == OBJ_BODY_MEMBER_LIST1555	}1556	fn cast(syntax: SyntaxNode) -> Option<Self> {1557		if Self::can_cast(syntax.kind()) {1558			Some(Self { syntax })1559		} else {1560			None1561		}1562	}1563	fn syntax(&self) -> &SyntaxNode {1564		&self.syntax1565	}1566}1567impl AstNode for MemberBindStmt {1568	fn can_cast(kind: SyntaxKind) -> bool {1569		kind == MEMBER_BIND_STMT1570	}1571	fn cast(syntax: SyntaxNode) -> Option<Self> {1572		if Self::can_cast(syntax.kind()) {1573			Some(Self { syntax })1574		} else {1575			None1576		}1577	}1578	fn syntax(&self) -> &SyntaxNode {1579		&self.syntax1580	}1581}1582impl AstNode for ObjLocal {1583	fn can_cast(kind: SyntaxKind) -> bool {1584		kind == OBJ_LOCAL1585	}1586	fn cast(syntax: SyntaxNode) -> Option<Self> {1587		if Self::can_cast(syntax.kind()) {1588			Some(Self { syntax })1589		} else {1590			None1591		}1592	}1593	fn syntax(&self) -> &SyntaxNode {1594		&self.syntax1595	}1596}1597impl AstNode for MemberAssertStmt {1598	fn can_cast(kind: SyntaxKind) -> bool {1599		kind == MEMBER_ASSERT_STMT1600	}1601	fn cast(syntax: SyntaxNode) -> Option<Self> {1602		if Self::can_cast(syntax.kind()) {1603			Some(Self { syntax })1604		} else {1605			None1606		}1607	}1608	fn syntax(&self) -> &SyntaxNode {1609		&self.syntax1610	}1611}1612impl AstNode for MemberFieldNormal {1613	fn can_cast(kind: SyntaxKind) -> bool {1614		kind == MEMBER_FIELD_NORMAL1615	}1616	fn cast(syntax: SyntaxNode) -> Option<Self> {1617		if Self::can_cast(syntax.kind()) {1618			Some(Self { syntax })1619		} else {1620			None1621		}1622	}1623	fn syntax(&self) -> &SyntaxNode {1624		&self.syntax1625	}1626}1627impl AstNode for MemberFieldMethod {1628	fn can_cast(kind: SyntaxKind) -> bool {1629		kind == MEMBER_FIELD_METHOD1630	}1631	fn cast(syntax: SyntaxNode) -> Option<Self> {1632		if Self::can_cast(syntax.kind()) {1633			Some(Self { syntax })1634		} else {1635			None1636		}1637	}1638	fn syntax(&self) -> &SyntaxNode {1639		&self.syntax1640	}1641}1642impl AstNode for FieldNameFixed {1643	fn can_cast(kind: SyntaxKind) -> bool {1644		kind == FIELD_NAME_FIXED1645	}1646	fn cast(syntax: SyntaxNode) -> Option<Self> {1647		if Self::can_cast(syntax.kind()) {1648			Some(Self { syntax })1649		} else {1650			None1651		}1652	}1653	fn syntax(&self) -> &SyntaxNode {1654		&self.syntax1655	}1656}1657impl AstNode for FieldNameDynamic {1658	fn can_cast(kind: SyntaxKind) -> bool {1659		kind == FIELD_NAME_DYNAMIC1660	}1661	fn cast(syntax: SyntaxNode) -> Option<Self> {1662		if Self::can_cast(syntax.kind()) {1663			Some(Self { syntax })1664		} else {1665			None1666		}1667	}1668	fn syntax(&self) -> &SyntaxNode {1669		&self.syntax1670	}1671}1672impl AstNode for ForSpec {1673	fn can_cast(kind: SyntaxKind) -> bool {1674		kind == FOR_SPEC1675	}1676	fn cast(syntax: SyntaxNode) -> Option<Self> {1677		if Self::can_cast(syntax.kind()) {1678			Some(Self { syntax })1679		} else {1680			None1681		}1682	}1683	fn syntax(&self) -> &SyntaxNode {1684		&self.syntax1685	}1686}1687impl AstNode for IfSpec {1688	fn can_cast(kind: SyntaxKind) -> bool {1689		kind == IF_SPEC1690	}1691	fn cast(syntax: SyntaxNode) -> Option<Self> {1692		if Self::can_cast(syntax.kind()) {1693			Some(Self { syntax })1694		} else {1695			None1696		}1697	}1698	fn syntax(&self) -> &SyntaxNode {1699		&self.syntax1700	}1701}1702impl AstNode for BindDestruct {1703	fn can_cast(kind: SyntaxKind) -> bool {1704		kind == BIND_DESTRUCT1705	}1706	fn cast(syntax: SyntaxNode) -> Option<Self> {1707		if Self::can_cast(syntax.kind()) {1708			Some(Self { syntax })1709		} else {1710			None1711		}1712	}1713	fn syntax(&self) -> &SyntaxNode {1714		&self.syntax1715	}1716}1717impl AstNode for BindFunction {1718	fn can_cast(kind: SyntaxKind) -> bool {1719		kind == BIND_FUNCTION1720	}1721	fn cast(syntax: SyntaxNode) -> Option<Self> {1722		if Self::can_cast(syntax.kind()) {1723			Some(Self { syntax })1724		} else {1725			None1726		}1727	}1728	fn syntax(&self) -> &SyntaxNode {1729		&self.syntax1730	}1731}1732impl AstNode for Param {1733	fn can_cast(kind: SyntaxKind) -> bool {1734		kind == PARAM1735	}1736	fn cast(syntax: SyntaxNode) -> Option<Self> {1737		if Self::can_cast(syntax.kind()) {1738			Some(Self { syntax })1739		} else {1740			None1741		}1742	}1743	fn syntax(&self) -> &SyntaxNode {1744		&self.syntax1745	}1746}1747impl AstNode for DestructFull {1748	fn can_cast(kind: SyntaxKind) -> bool {1749		kind == DESTRUCT_FULL1750	}1751	fn cast(syntax: SyntaxNode) -> Option<Self> {1752		if Self::can_cast(syntax.kind()) {1753			Some(Self { syntax })1754		} else {1755			None1756		}1757	}1758	fn syntax(&self) -> &SyntaxNode {1759		&self.syntax1760	}1761}1762impl AstNode for DestructSkip {1763	fn can_cast(kind: SyntaxKind) -> bool {1764		kind == DESTRUCT_SKIP1765	}1766	fn cast(syntax: SyntaxNode) -> Option<Self> {1767		if Self::can_cast(syntax.kind()) {1768			Some(Self { syntax })1769		} else {1770			None1771		}1772	}1773	fn syntax(&self) -> &SyntaxNode {1774		&self.syntax1775	}1776}1777impl AstNode for DestructArray {1778	fn can_cast(kind: SyntaxKind) -> bool {1779		kind == DESTRUCT_ARRAY1780	}1781	fn cast(syntax: SyntaxNode) -> Option<Self> {1782		if Self::can_cast(syntax.kind()) {1783			Some(Self { syntax })1784		} else {1785			None1786		}1787	}1788	fn syntax(&self) -> &SyntaxNode {1789		&self.syntax1790	}1791}1792impl AstNode for DestructObject {1793	fn can_cast(kind: SyntaxKind) -> bool {1794		kind == DESTRUCT_OBJECT1795	}1796	fn cast(syntax: SyntaxNode) -> Option<Self> {1797		if Self::can_cast(syntax.kind()) {1798			Some(Self { syntax })1799		} else {1800			None1801		}1802	}1803	fn syntax(&self) -> &SyntaxNode {1804		&self.syntax1805	}1806}1807impl AstNode for DestructObjectField {1808	fn can_cast(kind: SyntaxKind) -> bool {1809		kind == DESTRUCT_OBJECT_FIELD1810	}1811	fn cast(syntax: SyntaxNode) -> Option<Self> {1812		if Self::can_cast(syntax.kind()) {1813			Some(Self { syntax })1814		} else {1815			None1816		}1817	}1818	fn syntax(&self) -> &SyntaxNode {1819		&self.syntax1820	}1821}1822impl AstNode for DestructRest {1823	fn can_cast(kind: SyntaxKind) -> bool {1824		kind == DESTRUCT_REST1825	}1826	fn cast(syntax: SyntaxNode) -> Option<Self> {1827		if Self::can_cast(syntax.kind()) {1828			Some(Self { syntax })1829		} else {1830			None1831		}1832	}1833	fn syntax(&self) -> &SyntaxNode {1834		&self.syntax1835	}1836}1837impl AstNode for DestructArrayElement {1838	fn can_cast(kind: SyntaxKind) -> bool {1839		kind == DESTRUCT_ARRAY_ELEMENT1840	}1841	fn cast(syntax: SyntaxNode) -> Option<Self> {1842		if Self::can_cast(syntax.kind()) {1843			Some(Self { syntax })1844		} else {1845			None1846		}1847	}1848	fn syntax(&self) -> &SyntaxNode {1849		&self.syntax1850	}1851}1852impl From<ExprBinary> for Expr {1853	fn from(node: ExprBinary) -> Expr {1854		Expr::ExprBinary(node)1855	}1856}1857impl From<ExprUnary> for Expr {1858	fn from(node: ExprUnary) -> Expr {1859		Expr::ExprUnary(node)1860	}1861}1862impl From<ExprSlice> for Expr {1863	fn from(node: ExprSlice) -> Expr {1864		Expr::ExprSlice(node)1865	}1866}1867impl From<ExprIndex> for Expr {1868	fn from(node: ExprIndex) -> Expr {1869		Expr::ExprIndex(node)1870	}1871}1872impl From<ExprIndexExpr> for Expr {1873	fn from(node: ExprIndexExpr) -> Expr {1874		Expr::ExprIndexExpr(node)1875	}1876}1877impl From<ExprApply> for Expr {1878	fn from(node: ExprApply) -> Expr {1879		Expr::ExprApply(node)1880	}1881}1882impl From<ExprObjExtend> for Expr {1883	fn from(node: ExprObjExtend) -> Expr {1884		Expr::ExprObjExtend(node)1885	}1886}1887impl From<ExprParened> for Expr {1888	fn from(node: ExprParened) -> Expr {1889		Expr::ExprParened(node)1890	}1891}1892impl From<ExprString> for Expr {1893	fn from(node: ExprString) -> Expr {1894		Expr::ExprString(node)1895	}1896}1897impl From<ExprNumber> for Expr {1898	fn from(node: ExprNumber) -> Expr {1899		Expr::ExprNumber(node)1900	}1901}1902impl From<ExprLiteral> for Expr {1903	fn from(node: ExprLiteral) -> Expr {1904		Expr::ExprLiteral(node)1905	}1906}1907impl From<ExprArray> for Expr {1908	fn from(node: ExprArray) -> Expr {1909		Expr::ExprArray(node)1910	}1911}1912impl From<ExprObject> for Expr {1913	fn from(node: ExprObject) -> Expr {1914		Expr::ExprObject(node)1915	}1916}1917impl From<ExprArrayComp> for Expr {1918	fn from(node: ExprArrayComp) -> Expr {1919		Expr::ExprArrayComp(node)1920	}1921}1922impl From<ExprImport> for Expr {1923	fn from(node: ExprImport) -> Expr {1924		Expr::ExprImport(node)1925	}1926}1927impl From<ExprVar> for Expr {1928	fn from(node: ExprVar) -> Expr {1929		Expr::ExprVar(node)1930	}1931}1932impl From<ExprLocal> for Expr {1933	fn from(node: ExprLocal) -> Expr {1934		Expr::ExprLocal(node)1935	}1936}1937impl From<ExprIfThenElse> for Expr {1938	fn from(node: ExprIfThenElse) -> Expr {1939		Expr::ExprIfThenElse(node)1940	}1941}1942impl From<ExprFunction> for Expr {1943	fn from(node: ExprFunction) -> Expr {1944		Expr::ExprFunction(node)1945	}1946}1947impl From<ExprAssert> for Expr {1948	fn from(node: ExprAssert) -> Expr {1949		Expr::ExprAssert(node)1950	}1951}1952impl From<ExprError> for Expr {1953	fn from(node: ExprError) -> Expr {1954		Expr::ExprError(node)1955	}1956}1957impl AstNode for Expr {1958	fn can_cast(kind: SyntaxKind) -> bool {1959		match kind {1960			EXPR_BINARY | EXPR_UNARY | EXPR_SLICE | EXPR_INDEX | EXPR_INDEX_EXPR | EXPR_APPLY1961			| EXPR_OBJ_EXTEND | EXPR_PARENED | EXPR_STRING | EXPR_NUMBER | EXPR_LITERAL1962			| EXPR_ARRAY | EXPR_OBJECT | EXPR_ARRAY_COMP | EXPR_IMPORT | EXPR_VAR | EXPR_LOCAL1963			| EXPR_IF_THEN_ELSE | EXPR_FUNCTION | EXPR_ASSERT | EXPR_ERROR => true,1964			_ => false,1965		}1966	}1967	fn cast(syntax: SyntaxNode) -> Option<Self> {1968		let res = match syntax.kind() {1969			EXPR_BINARY => Expr::ExprBinary(ExprBinary { syntax }),1970			EXPR_UNARY => Expr::ExprUnary(ExprUnary { syntax }),1971			EXPR_SLICE => Expr::ExprSlice(ExprSlice { syntax }),1972			EXPR_INDEX => Expr::ExprIndex(ExprIndex { syntax }),1973			EXPR_INDEX_EXPR => Expr::ExprIndexExpr(ExprIndexExpr { syntax }),1974			EXPR_APPLY => Expr::ExprApply(ExprApply { syntax }),1975			EXPR_OBJ_EXTEND => Expr::ExprObjExtend(ExprObjExtend { syntax }),1976			EXPR_PARENED => Expr::ExprParened(ExprParened { syntax }),1977			EXPR_STRING => Expr::ExprString(ExprString { syntax }),1978			EXPR_NUMBER => Expr::ExprNumber(ExprNumber { syntax }),1979			EXPR_LITERAL => Expr::ExprLiteral(ExprLiteral { syntax }),1980			EXPR_ARRAY => Expr::ExprArray(ExprArray { syntax }),1981			EXPR_OBJECT => Expr::ExprObject(ExprObject { syntax }),1982			EXPR_ARRAY_COMP => Expr::ExprArrayComp(ExprArrayComp { syntax }),1983			EXPR_IMPORT => Expr::ExprImport(ExprImport { syntax }),1984			EXPR_VAR => Expr::ExprVar(ExprVar { syntax }),1985			EXPR_LOCAL => Expr::ExprLocal(ExprLocal { syntax }),1986			EXPR_IF_THEN_ELSE => Expr::ExprIfThenElse(ExprIfThenElse { syntax }),1987			EXPR_FUNCTION => Expr::ExprFunction(ExprFunction { syntax }),1988			EXPR_ASSERT => Expr::ExprAssert(ExprAssert { syntax }),1989			EXPR_ERROR => Expr::ExprError(ExprError { syntax }),1990			_ => return None,1991		};1992		Some(res)1993	}1994	fn syntax(&self) -> &SyntaxNode {1995		match self {1996			Expr::ExprBinary(it) => &it.syntax,1997			Expr::ExprUnary(it) => &it.syntax,1998			Expr::ExprSlice(it) => &it.syntax,1999			Expr::ExprIndex(it) => &it.syntax,2000			Expr::ExprIndexExpr(it) => &it.syntax,2001			Expr::ExprApply(it) => &it.syntax,2002			Expr::ExprObjExtend(it) => &it.syntax,2003			Expr::ExprParened(it) => &it.syntax,2004			Expr::ExprString(it) => &it.syntax,2005			Expr::ExprNumber(it) => &it.syntax,2006			Expr::ExprLiteral(it) => &it.syntax,2007			Expr::ExprArray(it) => &it.syntax,2008			Expr::ExprObject(it) => &it.syntax,2009			Expr::ExprArrayComp(it) => &it.syntax,2010			Expr::ExprImport(it) => &it.syntax,2011			Expr::ExprVar(it) => &it.syntax,2012			Expr::ExprLocal(it) => &it.syntax,2013			Expr::ExprIfThenElse(it) => &it.syntax,2014			Expr::ExprFunction(it) => &it.syntax,2015			Expr::ExprAssert(it) => &it.syntax,2016			Expr::ExprError(it) => &it.syntax,2017		}2018	}2019}2020impl From<ObjBodyComp> for ObjBody {2021	fn from(node: ObjBodyComp) -> ObjBody {2022		ObjBody::ObjBodyComp(node)2023	}2024}2025impl From<ObjBodyMemberList> for ObjBody {2026	fn from(node: ObjBodyMemberList) -> ObjBody {2027		ObjBody::ObjBodyMemberList(node)2028	}2029}2030impl AstNode for ObjBody {2031	fn can_cast(kind: SyntaxKind) -> bool {2032		match kind {2033			OBJ_BODY_COMP | OBJ_BODY_MEMBER_LIST => true,2034			_ => false,2035		}2036	}2037	fn cast(syntax: SyntaxNode) -> Option<Self> {2038		let res = match syntax.kind() {2039			OBJ_BODY_COMP => ObjBody::ObjBodyComp(ObjBodyComp { syntax }),2040			OBJ_BODY_MEMBER_LIST => ObjBody::ObjBodyMemberList(ObjBodyMemberList { syntax }),2041			_ => return None,2042		};2043		Some(res)2044	}2045	fn syntax(&self) -> &SyntaxNode {2046		match self {2047			ObjBody::ObjBodyComp(it) => &it.syntax,2048			ObjBody::ObjBodyMemberList(it) => &it.syntax,2049		}2050	}2051}2052impl From<ForSpec> for CompSpec {2053	fn from(node: ForSpec) -> CompSpec {2054		CompSpec::ForSpec(node)2055	}2056}2057impl From<IfSpec> for CompSpec {2058	fn from(node: IfSpec) -> CompSpec {2059		CompSpec::IfSpec(node)2060	}2061}2062impl AstNode for CompSpec {2063	fn can_cast(kind: SyntaxKind) -> bool {2064		match kind {2065			FOR_SPEC | IF_SPEC => true,2066			_ => false,2067		}2068	}2069	fn cast(syntax: SyntaxNode) -> Option<Self> {2070		let res = match syntax.kind() {2071			FOR_SPEC => CompSpec::ForSpec(ForSpec { syntax }),2072			IF_SPEC => CompSpec::IfSpec(IfSpec { syntax }),2073			_ => return None,2074		};2075		Some(res)2076	}2077	fn syntax(&self) -> &SyntaxNode {2078		match self {2079			CompSpec::ForSpec(it) => &it.syntax,2080			CompSpec::IfSpec(it) => &it.syntax,2081		}2082	}2083}2084impl From<BindDestruct> for Bind {2085	fn from(node: BindDestruct) -> Bind {2086		Bind::BindDestruct(node)2087	}2088}2089impl From<BindFunction> for Bind {2090	fn from(node: BindFunction) -> Bind {2091		Bind::BindFunction(node)2092	}2093}2094impl AstNode for Bind {2095	fn can_cast(kind: SyntaxKind) -> bool {2096		match kind {2097			BIND_DESTRUCT | BIND_FUNCTION => true,2098			_ => false,2099		}2100	}2101	fn cast(syntax: SyntaxNode) -> Option<Self> {2102		let res = match syntax.kind() {2103			BIND_DESTRUCT => Bind::BindDestruct(BindDestruct { syntax }),2104			BIND_FUNCTION => Bind::BindFunction(BindFunction { syntax }),2105			_ => return None,2106		};2107		Some(res)2108	}2109	fn syntax(&self) -> &SyntaxNode {2110		match self {2111			Bind::BindDestruct(it) => &it.syntax,2112			Bind::BindFunction(it) => &it.syntax,2113		}2114	}2115}2116impl From<MemberBindStmt> for MemberComp {2117	fn from(node: MemberBindStmt) -> MemberComp {2118		MemberComp::MemberBindStmt(node)2119	}2120}2121impl From<MemberFieldNormal> for MemberComp {2122	fn from(node: MemberFieldNormal) -> MemberComp {2123		MemberComp::MemberFieldNormal(node)2124	}2125}2126impl From<MemberFieldMethod> for MemberComp {2127	fn from(node: MemberFieldMethod) -> MemberComp {2128		MemberComp::MemberFieldMethod(node)2129	}2130}2131impl AstNode for MemberComp {2132	fn can_cast(kind: SyntaxKind) -> bool {2133		match kind {2134			MEMBER_BIND_STMT | MEMBER_FIELD_NORMAL | MEMBER_FIELD_METHOD => true,2135			_ => false,2136		}2137	}2138	fn cast(syntax: SyntaxNode) -> Option<Self> {2139		let res = match syntax.kind() {2140			MEMBER_BIND_STMT => MemberComp::MemberBindStmt(MemberBindStmt { syntax }),2141			MEMBER_FIELD_NORMAL => MemberComp::MemberFieldNormal(MemberFieldNormal { syntax }),2142			MEMBER_FIELD_METHOD => MemberComp::MemberFieldMethod(MemberFieldMethod { syntax }),2143			_ => return None,2144		};2145		Some(res)2146	}2147	fn syntax(&self) -> &SyntaxNode {2148		match self {2149			MemberComp::MemberBindStmt(it) => &it.syntax,2150			MemberComp::MemberFieldNormal(it) => &it.syntax,2151			MemberComp::MemberFieldMethod(it) => &it.syntax,2152		}2153	}2154}2155impl From<MemberBindStmt> for Member {2156	fn from(node: MemberBindStmt) -> Member {2157		Member::MemberBindStmt(node)2158	}2159}2160impl From<MemberAssertStmt> for Member {2161	fn from(node: MemberAssertStmt) -> Member {2162		Member::MemberAssertStmt(node)2163	}2164}2165impl From<MemberFieldNormal> for Member {2166	fn from(node: MemberFieldNormal) -> Member {2167		Member::MemberFieldNormal(node)2168	}2169}2170impl From<MemberFieldMethod> for Member {2171	fn from(node: MemberFieldMethod) -> Member {2172		Member::MemberFieldMethod(node)2173	}2174}2175impl AstNode for Member {2176	fn can_cast(kind: SyntaxKind) -> bool {2177		match kind {2178			MEMBER_BIND_STMT | MEMBER_ASSERT_STMT | MEMBER_FIELD_NORMAL | MEMBER_FIELD_METHOD => {2179				true2180			}2181			_ => false,2182		}2183	}2184	fn cast(syntax: SyntaxNode) -> Option<Self> {2185		let res = match syntax.kind() {2186			MEMBER_BIND_STMT => Member::MemberBindStmt(MemberBindStmt { syntax }),2187			MEMBER_ASSERT_STMT => Member::MemberAssertStmt(MemberAssertStmt { syntax }),2188			MEMBER_FIELD_NORMAL => Member::MemberFieldNormal(MemberFieldNormal { syntax }),2189			MEMBER_FIELD_METHOD => Member::MemberFieldMethod(MemberFieldMethod { syntax }),2190			_ => return None,2191		};2192		Some(res)2193	}2194	fn syntax(&self) -> &SyntaxNode {2195		match self {2196			Member::MemberBindStmt(it) => &it.syntax,2197			Member::MemberAssertStmt(it) => &it.syntax,2198			Member::MemberFieldNormal(it) => &it.syntax,2199			Member::MemberFieldMethod(it) => &it.syntax,2200		}2201	}2202}2203impl From<FieldNameFixed> for FieldName {2204	fn from(node: FieldNameFixed) -> FieldName {2205		FieldName::FieldNameFixed(node)2206	}2207}2208impl From<FieldNameDynamic> for FieldName {2209	fn from(node: FieldNameDynamic) -> FieldName {2210		FieldName::FieldNameDynamic(node)2211	}2212}2213impl AstNode for FieldName {2214	fn can_cast(kind: SyntaxKind) -> bool {2215		match kind {2216			FIELD_NAME_FIXED | FIELD_NAME_DYNAMIC => true,2217			_ => false,2218		}2219	}2220	fn cast(syntax: SyntaxNode) -> Option<Self> {2221		let res = match syntax.kind() {2222			FIELD_NAME_FIXED => FieldName::FieldNameFixed(FieldNameFixed { syntax }),2223			FIELD_NAME_DYNAMIC => FieldName::FieldNameDynamic(FieldNameDynamic { syntax }),2224			_ => return None,2225		};2226		Some(res)2227	}2228	fn syntax(&self) -> &SyntaxNode {2229		match self {2230			FieldName::FieldNameFixed(it) => &it.syntax,2231			FieldName::FieldNameDynamic(it) => &it.syntax,2232		}2233	}2234}2235impl From<DestructFull> for Destruct {2236	fn from(node: DestructFull) -> Destruct {2237		Destruct::DestructFull(node)2238	}2239}2240impl From<DestructSkip> for Destruct {2241	fn from(node: DestructSkip) -> Destruct {2242		Destruct::DestructSkip(node)2243	}2244}2245impl From<DestructArray> for Destruct {2246	fn from(node: DestructArray) -> Destruct {2247		Destruct::DestructArray(node)2248	}2249}2250impl From<DestructObject> for Destruct {2251	fn from(node: DestructObject) -> Destruct {2252		Destruct::DestructObject(node)2253	}2254}2255impl AstNode for Destruct {2256	fn can_cast(kind: SyntaxKind) -> bool {2257		match kind {2258			DESTRUCT_FULL | DESTRUCT_SKIP | DESTRUCT_ARRAY | DESTRUCT_OBJECT => true,2259			_ => false,2260		}2261	}2262	fn cast(syntax: SyntaxNode) -> Option<Self> {2263		let res = match syntax.kind() {2264			DESTRUCT_FULL => Destruct::DestructFull(DestructFull { syntax }),2265			DESTRUCT_SKIP => Destruct::DestructSkip(DestructSkip { syntax }),2266			DESTRUCT_ARRAY => Destruct::DestructArray(DestructArray { syntax }),2267			DESTRUCT_OBJECT => Destruct::DestructObject(DestructObject { syntax }),2268			_ => return None,2269		};2270		Some(res)2271	}2272	fn syntax(&self) -> &SyntaxNode {2273		match self {2274			Destruct::DestructFull(it) => &it.syntax,2275			Destruct::DestructSkip(it) => &it.syntax,2276			Destruct::DestructArray(it) => &it.syntax,2277			Destruct::DestructObject(it) => &it.syntax,2278		}2279	}2280}2281impl From<DestructArrayElement> for DestructArrayPart {2282	fn from(node: DestructArrayElement) -> DestructArrayPart {2283		DestructArrayPart::DestructArrayElement(node)2284	}2285}2286impl From<DestructRest> for DestructArrayPart {2287	fn from(node: DestructRest) -> DestructArrayPart {2288		DestructArrayPart::DestructRest(node)2289	}2290}2291impl AstNode for DestructArrayPart {2292	fn can_cast(kind: SyntaxKind) -> bool {2293		match kind {2294			DESTRUCT_ARRAY_ELEMENT | DESTRUCT_REST => true,2295			_ => false,2296		}2297	}2298	fn cast(syntax: SyntaxNode) -> Option<Self> {2299		let res = match syntax.kind() {2300			DESTRUCT_ARRAY_ELEMENT => {2301				DestructArrayPart::DestructArrayElement(DestructArrayElement { syntax })2302			}2303			DESTRUCT_REST => DestructArrayPart::DestructRest(DestructRest { syntax }),2304			_ => return None,2305		};2306		Some(res)2307	}2308	fn syntax(&self) -> &SyntaxNode {2309		match self {2310			DestructArrayPart::DestructArrayElement(it) => &it.syntax,2311			DestructArrayPart::DestructRest(it) => &it.syntax,2312		}2313	}2314}2315impl AstToken for BinaryOperator {2316	fn can_cast(kind: SyntaxKind) -> bool {2317		BinaryOperatorKind::can_cast(kind)2318	}2319	fn cast(syntax: SyntaxToken) -> Option<Self> {2320		let kind = BinaryOperatorKind::cast(syntax.kind())?;2321		Some(BinaryOperator { syntax, kind })2322	}2323	fn syntax(&self) -> &SyntaxToken {2324		&self.syntax2325	}2326}2327impl BinaryOperatorKind {2328	fn can_cast(kind: SyntaxKind) -> bool {2329		match kind {2330			OR | AND | BIT_OR | BIT_XOR | BIT_AND | EQ | NE | LT | GT | LE | GE | IN_KW | LHS2331			| RHS | PLUS | MINUS | MUL | DIV | MODULO | META_OBJECT_APPLY | ERROR_NO_OPERATOR => true,2332			_ => false,2333		}2334	}2335	pub fn cast(kind: SyntaxKind) -> Option<Self> {2336		let res = match kind {2337			OR => Self::Or,2338			AND => Self::And,2339			BIT_OR => Self::BitOr,2340			BIT_XOR => Self::BitXor,2341			BIT_AND => Self::BitAnd,2342			EQ => Self::Eq,2343			NE => Self::Ne,2344			LT => Self::Lt,2345			GT => Self::Gt,2346			LE => Self::Le,2347			GE => Self::Ge,2348			IN_KW => Self::InKw,2349			LHS => Self::Lhs,2350			RHS => Self::Rhs,2351			PLUS => Self::Plus,2352			MINUS => Self::Minus,2353			MUL => Self::Mul,2354			DIV => Self::Div,2355			MODULO => Self::Modulo,2356			META_OBJECT_APPLY => Self::MetaObjectApply,2357			ERROR_NO_OPERATOR => Self::ErrorNoOperator,2358			_ => return None,2359		};2360		Some(res)2361	}2362}2363impl BinaryOperator {2364	pub fn kind(&self) -> BinaryOperatorKind {2365		self.kind2366	}2367}2368impl std::fmt::Display for BinaryOperator {2369	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2370		std::fmt::Display::fmt(self.syntax(), f)2371	}2372}2373impl AstToken for UnaryOperator {2374	fn can_cast(kind: SyntaxKind) -> bool {2375		UnaryOperatorKind::can_cast(kind)2376	}2377	fn cast(syntax: SyntaxToken) -> Option<Self> {2378		let kind = UnaryOperatorKind::cast(syntax.kind())?;2379		Some(UnaryOperator { syntax, kind })2380	}2381	fn syntax(&self) -> &SyntaxToken {2382		&self.syntax2383	}2384}2385impl UnaryOperatorKind {2386	fn can_cast(kind: SyntaxKind) -> bool {2387		match kind {2388			MINUS | NOT | BIT_NOT => true,2389			_ => false,2390		}2391	}2392	pub fn cast(kind: SyntaxKind) -> Option<Self> {2393		let res = match kind {2394			MINUS => Self::Minus,2395			NOT => Self::Not,2396			BIT_NOT => Self::BitNot,2397			_ => return None,2398		};2399		Some(res)2400	}2401}2402impl UnaryOperator {2403	pub fn kind(&self) -> UnaryOperatorKind {2404		self.kind2405	}2406}2407impl std::fmt::Display for UnaryOperator {2408	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2409		std::fmt::Display::fmt(self.syntax(), f)2410	}2411}2412impl AstToken for Literal {2413	fn can_cast(kind: SyntaxKind) -> bool {2414		LiteralKind::can_cast(kind)2415	}2416	fn cast(syntax: SyntaxToken) -> Option<Self> {2417		let kind = LiteralKind::cast(syntax.kind())?;2418		Some(Literal { syntax, kind })2419	}2420	fn syntax(&self) -> &SyntaxToken {2421		&self.syntax2422	}2423}2424impl LiteralKind {2425	fn can_cast(kind: SyntaxKind) -> bool {2426		match kind {2427			NULL_KW | TRUE_KW | FALSE_KW | SELF_KW | DOLLAR | SUPER_KW => true,2428			_ => false,2429		}2430	}2431	pub fn cast(kind: SyntaxKind) -> Option<Self> {2432		let res = match kind {2433			NULL_KW => Self::NullKw,2434			TRUE_KW => Self::TrueKw,2435			FALSE_KW => Self::FalseKw,2436			SELF_KW => Self::SelfKw,2437			DOLLAR => Self::Dollar,2438			SUPER_KW => Self::SuperKw,2439			_ => return None,2440		};2441		Some(res)2442	}2443}2444impl Literal {2445	pub fn kind(&self) -> LiteralKind {2446		self.kind2447	}2448}2449impl std::fmt::Display for Literal {2450	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2451		std::fmt::Display::fmt(self.syntax(), f)2452	}2453}2454impl AstToken for Text {2455	fn can_cast(kind: SyntaxKind) -> bool {2456		TextKind::can_cast(kind)2457	}2458	fn cast(syntax: SyntaxToken) -> Option<Self> {2459		let kind = TextKind::cast(syntax.kind())?;2460		Some(Text { syntax, kind })2461	}2462	fn syntax(&self) -> &SyntaxToken {2463		&self.syntax2464	}2465}2466impl TextKind {2467	fn can_cast(kind: SyntaxKind) -> bool {2468		match kind {2469			STRING_DOUBLE2470			| ERROR_STRING_DOUBLE_UNTERMINATED2471			| STRING_SINGLE2472			| ERROR_STRING_SINGLE_UNTERMINATED2473			| STRING_DOUBLE_VERBATIM2474			| ERROR_STRING_DOUBLE_VERBATIM_UNTERMINATED2475			| STRING_SINGLE_VERBATIM2476			| ERROR_STRING_SINGLE_VERBATIM_UNTERMINATED2477			| ERROR_STRING_VERBATIM_MISSING_QUOTES2478			| STRING_BLOCK2479			| ERROR_STRING_BLOCK_UNEXPECTED_END2480			| ERROR_STRING_BLOCK_MISSING_NEW_LINE2481			| ERROR_STRING_BLOCK_MISSING_TERMINATION2482			| ERROR_STRING_BLOCK_MISSING_INDENT => true,2483			_ => false,2484		}2485	}2486	pub fn cast(kind: SyntaxKind) -> Option<Self> {2487		let res = match kind {2488			STRING_DOUBLE => Self::StringDouble,2489			ERROR_STRING_DOUBLE_UNTERMINATED => Self::ErrorStringDoubleUnterminated,2490			STRING_SINGLE => Self::StringSingle,2491			ERROR_STRING_SINGLE_UNTERMINATED => Self::ErrorStringSingleUnterminated,2492			STRING_DOUBLE_VERBATIM => Self::StringDoubleVerbatim,2493			ERROR_STRING_DOUBLE_VERBATIM_UNTERMINATED => {2494				Self::ErrorStringDoubleVerbatimUnterminated2495			}2496			STRING_SINGLE_VERBATIM => Self::StringSingleVerbatim,2497			ERROR_STRING_SINGLE_VERBATIM_UNTERMINATED => {2498				Self::ErrorStringSingleVerbatimUnterminated2499			}2500			ERROR_STRING_VERBATIM_MISSING_QUOTES => Self::ErrorStringVerbatimMissingQuotes,2501			STRING_BLOCK => Self::StringBlock,2502			ERROR_STRING_BLOCK_UNEXPECTED_END => Self::ErrorStringBlockUnexpectedEnd,2503			ERROR_STRING_BLOCK_MISSING_NEW_LINE => Self::ErrorStringBlockMissingNewLine,2504			ERROR_STRING_BLOCK_MISSING_TERMINATION => Self::ErrorStringBlockMissingTermination,2505			ERROR_STRING_BLOCK_MISSING_INDENT => Self::ErrorStringBlockMissingIndent,2506			_ => return None,2507		};2508		Some(res)2509	}2510}2511impl Text {2512	pub fn kind(&self) -> TextKind {2513		self.kind2514	}2515}2516impl std::fmt::Display for Text {2517	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2518		std::fmt::Display::fmt(self.syntax(), f)2519	}2520}2521impl AstToken for Number {2522	fn can_cast(kind: SyntaxKind) -> bool {2523		NumberKind::can_cast(kind)2524	}2525	fn cast(syntax: SyntaxToken) -> Option<Self> {2526		let kind = NumberKind::cast(syntax.kind())?;2527		Some(Number { syntax, kind })2528	}2529	fn syntax(&self) -> &SyntaxToken {2530		&self.syntax2531	}2532}2533impl NumberKind {2534	fn can_cast(kind: SyntaxKind) -> bool {2535		match kind {2536			FLOAT2537			| ERROR_FLOAT_JUNK_AFTER_POINT2538			| ERROR_FLOAT_JUNK_AFTER_EXPONENT2539			| ERROR_FLOAT_JUNK_AFTER_EXPONENT_SIGN => true,2540			_ => false,2541		}2542	}2543	pub fn cast(kind: SyntaxKind) -> Option<Self> {2544		let res = match kind {2545			FLOAT => Self::Float,2546			ERROR_FLOAT_JUNK_AFTER_POINT => Self::ErrorFloatJunkAfterPoint,2547			ERROR_FLOAT_JUNK_AFTER_EXPONENT => Self::ErrorFloatJunkAfterExponent,2548			ERROR_FLOAT_JUNK_AFTER_EXPONENT_SIGN => Self::ErrorFloatJunkAfterExponentSign,2549			_ => return None,2550		};2551		Some(res)2552	}2553}2554impl Number {2555	pub fn kind(&self) -> NumberKind {2556		self.kind2557	}2558}2559impl std::fmt::Display for Number {2560	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2561		std::fmt::Display::fmt(self.syntax(), f)2562	}2563}2564impl AstToken for ImportKind {2565	fn can_cast(kind: SyntaxKind) -> bool {2566		ImportKindKind::can_cast(kind)2567	}2568	fn cast(syntax: SyntaxToken) -> Option<Self> {2569		let kind = ImportKindKind::cast(syntax.kind())?;2570		Some(ImportKind { syntax, kind })2571	}2572	fn syntax(&self) -> &SyntaxToken {2573		&self.syntax2574	}2575}2576impl ImportKindKind {2577	fn can_cast(kind: SyntaxKind) -> bool {2578		match kind {2579			IMPORTSTR_KW | IMPORTBIN_KW | IMPORT_KW => true,2580			_ => false,2581		}2582	}2583	pub fn cast(kind: SyntaxKind) -> Option<Self> {2584		let res = match kind {2585			IMPORTSTR_KW => Self::ImportstrKw,2586			IMPORTBIN_KW => Self::ImportbinKw,2587			IMPORT_KW => Self::ImportKw,2588			_ => return None,2589		};2590		Some(res)2591	}2592}2593impl ImportKind {2594	pub fn kind(&self) -> ImportKindKind {2595		self.kind2596	}2597}2598impl std::fmt::Display for ImportKind {2599	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2600		std::fmt::Display::fmt(self.syntax(), f)2601	}2602}2603impl AstToken for Visibility {2604	fn can_cast(kind: SyntaxKind) -> bool {2605		VisibilityKind::can_cast(kind)2606	}2607	fn cast(syntax: SyntaxToken) -> Option<Self> {2608		let kind = VisibilityKind::cast(syntax.kind())?;2609		Some(Visibility { syntax, kind })2610	}2611	fn syntax(&self) -> &SyntaxToken {2612		&self.syntax2613	}2614}2615impl VisibilityKind {2616	fn can_cast(kind: SyntaxKind) -> bool {2617		match kind {2618			COLONCOLONCOLON | COLONCOLON | COLON => true,2619			_ => false,2620		}2621	}2622	pub fn cast(kind: SyntaxKind) -> Option<Self> {2623		let res = match kind {2624			COLONCOLONCOLON => Self::Coloncoloncolon,2625			COLONCOLON => Self::Coloncolon,2626			COLON => Self::Colon,2627			_ => return None,2628		};2629		Some(res)2630	}2631}2632impl Visibility {2633	pub fn kind(&self) -> VisibilityKind {2634		self.kind2635	}2636}2637impl std::fmt::Display for Visibility {2638	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2639		std::fmt::Display::fmt(self.syntax(), f)2640	}2641}2642impl AstToken for Trivia {2643	fn can_cast(kind: SyntaxKind) -> bool {2644		TriviaKind::can_cast(kind)2645	}2646	fn cast(syntax: SyntaxToken) -> Option<Self> {2647		let kind = TriviaKind::cast(syntax.kind())?;2648		Some(Trivia { syntax, kind })2649	}2650	fn syntax(&self) -> &SyntaxToken {2651		&self.syntax2652	}2653}2654impl TriviaKind {2655	fn can_cast(kind: SyntaxKind) -> bool {2656		match kind {2657			WHITESPACE2658			| MULTI_LINE_COMMENT2659			| ERROR_COMMENT_TOO_SHORT2660			| ERROR_COMMENT_UNTERMINATED2661			| SINGLE_LINE_HASH_COMMENT2662			| SINGLE_LINE_SLASH_COMMENT => true,2663			_ => false,2664		}2665	}2666	pub fn cast(kind: SyntaxKind) -> Option<Self> {2667		let res = match kind {2668			WHITESPACE => Self::Whitespace,2669			MULTI_LINE_COMMENT => Self::MultiLineComment,2670			ERROR_COMMENT_TOO_SHORT => Self::ErrorCommentTooShort,2671			ERROR_COMMENT_UNTERMINATED => Self::ErrorCommentUnterminated,2672			SINGLE_LINE_HASH_COMMENT => Self::SingleLineHashComment,2673			SINGLE_LINE_SLASH_COMMENT => Self::SingleLineSlashComment,2674			_ => return None,2675		};2676		Some(res)2677	}2678}2679impl Trivia {2680	pub fn kind(&self) -> TriviaKind {2681		self.kind2682	}2683}2684impl std::fmt::Display for Trivia {2685	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2686		std::fmt::Display::fmt(self.syntax(), f)2687	}2688}2689impl AstToken for CustomError {2690	fn can_cast(kind: SyntaxKind) -> bool {2691		CustomErrorKind::can_cast(kind)2692	}2693	fn cast(syntax: SyntaxToken) -> Option<Self> {2694		let kind = CustomErrorKind::cast(syntax.kind())?;2695		Some(CustomError { syntax, kind })2696	}2697	fn syntax(&self) -> &SyntaxToken {2698		&self.syntax2699	}2700}2701impl CustomErrorKind {2702	fn can_cast(kind: SyntaxKind) -> bool {2703		match kind {2704			ERROR_MISSING_TOKEN | ERROR_UNEXPECTED_TOKEN | ERROR_CUSTOM => true,2705			_ => false,2706		}2707	}2708	pub fn cast(kind: SyntaxKind) -> Option<Self> {2709		let res = match kind {2710			ERROR_MISSING_TOKEN => Self::ErrorMissingToken,2711			ERROR_UNEXPECTED_TOKEN => Self::ErrorUnexpectedToken,2712			ERROR_CUSTOM => Self::ErrorCustom,2713			_ => return None,2714		};2715		Some(res)2716	}2717}2718impl CustomError {2719	pub fn kind(&self) -> CustomErrorKind {2720		self.kind2721	}2722}2723impl std::fmt::Display for CustomError {2724	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2725		std::fmt::Display::fmt(self.syntax(), f)2726	}2727}2728impl std::fmt::Display for Expr {2729	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2730		std::fmt::Display::fmt(self.syntax(), f)2731	}2732}2733impl std::fmt::Display for ObjBody {2734	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2735		std::fmt::Display::fmt(self.syntax(), f)2736	}2737}2738impl std::fmt::Display for CompSpec {2739	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2740		std::fmt::Display::fmt(self.syntax(), f)2741	}2742}2743impl std::fmt::Display for Bind {2744	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2745		std::fmt::Display::fmt(self.syntax(), f)2746	}2747}2748impl std::fmt::Display for MemberComp {2749	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2750		std::fmt::Display::fmt(self.syntax(), f)2751	}2752}2753impl std::fmt::Display for Member {2754	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2755		std::fmt::Display::fmt(self.syntax(), f)2756	}2757}2758impl std::fmt::Display for FieldName {2759	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2760		std::fmt::Display::fmt(self.syntax(), f)2761	}2762}2763impl std::fmt::Display for Destruct {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 DestructArrayPart {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 SourceFile {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 ExprBinary {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 LhsExpr {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 ExprUnary {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 ExprSlice {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 SliceDesc {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 ExprIndex {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 Name {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 ExprIndexExpr {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 ExprApply {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 ArgsDesc {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 ExprObjExtend {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 ExprParened {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 ExprLiteral {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 ExprString {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 ExprNumber {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 ExprArray {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 ExprObject {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 ExprArrayComp {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 ExprImport {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 ExprVar {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 ExprLocal {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 ExprIfThenElse {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 TrueExpr {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 FalseExpr {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 ExprFunction {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 ParamsDesc {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 ExprAssert {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 Assertion {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 ExprError {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 SliceDescEnd {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 SliceDescStep {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 Arg {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 ObjBodyComp {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 ObjBodyMemberList {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 MemberBindStmt {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 ObjLocal {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 MemberAssertStmt {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 MemberFieldNormal {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 MemberFieldMethod {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 FieldNameFixed {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 FieldNameDynamic {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 ForSpec {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 IfSpec {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 BindDestruct {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 BindFunction {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 Param {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 DestructFull {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 DestructSkip {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 DestructArray {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 DestructObject {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 DestructObjectField {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 DestructRest {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 DestructArrayElement {3039	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3040		std::fmt::Display::fmt(self.syntax(), f)3041	}3042}