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

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)]5use crate::{6	ast::{self, support, AstChildren, AstNode},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> { support::child(&self.syntax) }17}1819#[derive(Debug, Clone, PartialEq, Eq, Hash)]20pub struct ExprBinary {21	pub(crate) syntax: SyntaxNode,22}23impl ExprBinary {24	pub fn lhs(&self) -> Option<Expr> { support::child(&self.syntax) }25	pub fn binary_operator(&self) -> Option<BinaryOperator> { support::child(&self.syntax) }26	pub fn rhs(&self) -> Option<Expr> { support::child(&self.syntax) }27}2829#[derive(Debug, Clone, PartialEq, Eq, Hash)]30pub struct BinaryOperator {31	pub(crate) syntax: SyntaxNode,32}33impl BinaryOperator {34	pub fn or_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![||]) }35	pub fn and_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![&&]) }36	pub fn bit_or_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![|]) }37	pub fn bit_xor_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![^]) }38	pub fn bit_and_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![&]) }39	pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![==]) }40	pub fn ne_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!=]) }41	pub fn lt_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![<]) }42	pub fn gt_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![>]) }43	pub fn le_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![<=]) }44	pub fn ge_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![>=]) }45	pub fn in_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![in]) }46	pub fn lhs_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![<<]) }47	pub fn rhs_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![>>]) }48	pub fn plus_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![+]) }49	pub fn minus_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![-]) }50	pub fn mul_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![*]) }51	pub fn div_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![/]) }52	pub fn modulo_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![%]) }53}5455#[derive(Debug, Clone, PartialEq, Eq, Hash)]56pub struct ExprUnary {57	pub(crate) syntax: SyntaxNode,58}59impl ExprUnary {60	pub fn unary_operator(&self) -> Option<UnaryOperator> { support::child(&self.syntax) }61	pub fn rhs(&self) -> Option<Expr> { support::child(&self.syntax) }62}6364#[derive(Debug, Clone, PartialEq, Eq, Hash)]65pub struct UnaryOperator {66	pub(crate) syntax: SyntaxNode,67}68impl UnaryOperator {69	pub fn minus_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![-]) }70	pub fn not_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) }71	pub fn bit_not_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![~]) }72}7374#[derive(Debug, Clone, PartialEq, Eq, Hash)]75pub struct ExprSlice {76	pub(crate) syntax: SyntaxNode,77}78impl ExprSlice {79	pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }80	pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }81	pub fn slice_desc(&self) -> Option<SliceDesc> { support::child(&self.syntax) }82	pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }83}8485#[derive(Debug, Clone, PartialEq, Eq, Hash)]86pub struct SliceDesc {87	pub(crate) syntax: SyntaxNode,88}89impl SliceDesc {90	pub fn from(&self) -> Option<Expr> { support::child(&self.syntax) }91	pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }92	pub fn end(&self) -> Option<Expr> { support::child(&self.syntax) }93	pub fn step(&self) -> Option<Expr> { support::child(&self.syntax) }94}9596#[derive(Debug, Clone, PartialEq, Eq, Hash)]97pub struct ExprIndex {98	pub(crate) syntax: SyntaxNode,99}100impl ExprIndex {101	pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }102	pub fn dot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![.]) }103	pub fn index(&self) -> Option<Name> { support::child(&self.syntax) }104}105106#[derive(Debug, Clone, PartialEq, Eq, Hash)]107pub struct Name {108	pub(crate) syntax: SyntaxNode,109}110impl Name {111	pub fn ident_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![ident]) }112}113114#[derive(Debug, Clone, PartialEq, Eq, Hash)]115pub struct ExprIndexExpr {116	pub(crate) syntax: SyntaxNode,117}118impl ExprIndexExpr {119	pub fn base(&self) -> Option<Expr> { support::child(&self.syntax) }120	pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }121	pub fn index(&self) -> Option<Expr> { support::child(&self.syntax) }122	pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }123}124125#[derive(Debug, Clone, PartialEq, Eq, Hash)]126pub struct ExprApply {127	pub(crate) syntax: SyntaxNode,128}129impl ExprApply {130	pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }131	pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }132	pub fn args_desc(&self) -> Option<ArgsDesc> { support::child(&self.syntax) }133	pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }134	pub fn tailstrict_token(&self) -> Option<SyntaxToken> {135		support::token(&self.syntax, T![tailstrict])136	}137}138139#[derive(Debug, Clone, PartialEq, Eq, Hash)]140pub struct ArgsDesc {141	pub(crate) syntax: SyntaxNode,142}143impl ArgsDesc {144	pub fn args(&self) -> AstChildren<Arg> { support::children(&self.syntax) }145}146147#[derive(Debug, Clone, PartialEq, Eq, Hash)]148pub struct ExprObjExtend {149	pub(crate) syntax: SyntaxNode,150}151impl ExprObjExtend {152	pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }153	pub fn l_brace_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }154	pub fn obj_body(&self) -> Option<ObjBody> { support::child(&self.syntax) }155	pub fn r_brace_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }156}157158#[derive(Debug, Clone, PartialEq, Eq, Hash)]159pub struct ExprParened {160	pub(crate) syntax: SyntaxNode,161}162impl ExprParened {163	pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }164	pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }165	pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }166}167168#[derive(Debug, Clone, PartialEq, Eq, Hash)]169pub struct ExprLiteral {170	pub(crate) syntax: SyntaxNode,171}172impl ExprLiteral {173	pub fn literal(&self) -> Option<Literal> { support::child(&self.syntax) }174}175176#[derive(Debug, Clone, PartialEq, Eq, Hash)]177pub struct Literal {178	pub(crate) syntax: SyntaxNode,179}180impl Literal {181	pub fn null_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![null]) }182	pub fn true_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![true]) }183	pub fn false_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![false]) }184	pub fn self_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![self]) }185	pub fn dollar_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['$']) }186	pub fn super_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![super]) }187}188189#[derive(Debug, Clone, PartialEq, Eq, Hash)]190pub struct ExprIntrinsicThisFile {191	pub(crate) syntax: SyntaxNode,192}193impl ExprIntrinsicThisFile {194	pub fn intrinsic_this_file_token(&self) -> Option<SyntaxToken> {195		support::token(&self.syntax, T!["$intrinsicThisFile"])196	}197}198199#[derive(Debug, Clone, PartialEq, Eq, Hash)]200pub struct ExprIntrinsicId {201	pub(crate) syntax: SyntaxNode,202}203impl ExprIntrinsicId {204	pub fn intrinsic_id_token(&self) -> Option<SyntaxToken> {205		support::token(&self.syntax, T!["$intrinsicId"])206	}207}208209#[derive(Debug, Clone, PartialEq, Eq, Hash)]210pub struct ExprIntrinsic {211	pub(crate) syntax: SyntaxNode,212}213impl ExprIntrinsic {214	pub fn intrinsic_token(&self) -> Option<SyntaxToken> {215		support::token(&self.syntax, T!["$intrinsic"])216	}217	pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }218	pub fn name(&self) -> Option<Name> { support::child(&self.syntax) }219	pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }220}221222#[derive(Debug, Clone, PartialEq, Eq, Hash)]223pub struct ExprString {224	pub(crate) syntax: SyntaxNode,225}226impl ExprString {227	pub fn string(&self) -> Option<String> { support::child(&self.syntax) }228}229230#[derive(Debug, Clone, PartialEq, Eq, Hash)]231pub struct String {232	pub(crate) syntax: SyntaxNode,233}234impl String {235	pub fn string_double_token(&self) -> Option<SyntaxToken> {236		support::token(&self.syntax, T![string_double])237	}238	pub fn string_single_token(&self) -> Option<SyntaxToken> {239		support::token(&self.syntax, T![string_single])240	}241	pub fn string_double_verbatim_token(&self) -> Option<SyntaxToken> {242		support::token(&self.syntax, T![string_double_verbatim])243	}244	pub fn string_single_verbatim_token(&self) -> Option<SyntaxToken> {245		support::token(&self.syntax, T![string_single_verbatim])246	}247	pub fn string_block_token(&self) -> Option<SyntaxToken> {248		support::token(&self.syntax, T![string_block])249	}250}251252#[derive(Debug, Clone, PartialEq, Eq, Hash)]253pub struct ExprNumber {254	pub(crate) syntax: SyntaxNode,255}256impl ExprNumber {257	pub fn number(&self) -> Option<Number> { support::child(&self.syntax) }258}259260#[derive(Debug, Clone, PartialEq, Eq, Hash)]261pub struct Number {262	pub(crate) syntax: SyntaxNode,263}264impl Number {265	pub fn number_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![number]) }266}267268#[derive(Debug, Clone, PartialEq, Eq, Hash)]269pub struct ExprArray {270	pub(crate) syntax: SyntaxNode,271}272impl ExprArray {273	pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }274	pub fn exprs(&self) -> AstChildren<Expr> { support::children(&self.syntax) }275	pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }276}277278#[derive(Debug, Clone, PartialEq, Eq, Hash)]279pub struct ExprObject {280	pub(crate) syntax: SyntaxNode,281}282impl ExprObject {283	pub fn l_brace_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }284	pub fn obj_body(&self) -> Option<ObjBody> { support::child(&self.syntax) }285	pub fn r_brace_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }286}287288#[derive(Debug, Clone, PartialEq, Eq, Hash)]289pub struct ExprArrayComp {290	pub(crate) syntax: SyntaxNode,291}292impl ExprArrayComp {293	pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }294	pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }295	pub fn comma_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![,]) }296	pub fn for_spec(&self) -> Option<ForSpec> { support::child(&self.syntax) }297	pub fn comp_specs(&self) -> AstChildren<CompSpec> { support::children(&self.syntax) }298	pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }299}300301#[derive(Debug, Clone, PartialEq, Eq, Hash)]302pub struct ForSpec {303	pub(crate) syntax: SyntaxNode,304}305impl ForSpec {306	pub fn for_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![for]) }307	pub fn bind(&self) -> Option<Name> { support::child(&self.syntax) }308	pub fn in_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![in]) }309	pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }310}311312#[derive(Debug, Clone, PartialEq, Eq, Hash)]313pub struct ExprImport {314	pub(crate) syntax: SyntaxNode,315}316impl ExprImport {317	pub fn importstr_token(&self) -> Option<SyntaxToken> {318		support::token(&self.syntax, T![importstr])319	}320	pub fn string(&self) -> Option<String> { support::child(&self.syntax) }321	pub fn importbin_token(&self) -> Option<SyntaxToken> {322		support::token(&self.syntax, T![importbin])323	}324	pub fn import_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![import]) }325}326327#[derive(Debug, Clone, PartialEq, Eq, Hash)]328pub struct ExprVar {329	pub(crate) syntax: SyntaxNode,330}331impl ExprVar {332	pub fn name(&self) -> Option<Name> { support::child(&self.syntax) }333}334335#[derive(Debug, Clone, PartialEq, Eq, Hash)]336pub struct ExprLocal {337	pub(crate) syntax: SyntaxNode,338}339impl ExprLocal {340	pub fn local_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![local]) }341	pub fn binds(&self) -> AstChildren<Bind> { support::children(&self.syntax) }342	pub fn semi_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }343}344345#[derive(Debug, Clone, PartialEq, Eq, Hash)]346pub struct ExprIfThenElse {347	pub(crate) syntax: SyntaxNode,348}349impl ExprIfThenElse {350	pub fn if_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![if]) }351	pub fn cond(&self) -> Option<Expr> { support::child(&self.syntax) }352	pub fn then_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![then]) }353	pub fn then(&self) -> Option<Expr> { support::child(&self.syntax) }354	pub fn else_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![else]) }355	pub fn else_(&self) -> Option<Expr> { support::child(&self.syntax) }356}357358#[derive(Debug, Clone, PartialEq, Eq, Hash)]359pub struct ExprFunction {360	pub(crate) syntax: SyntaxNode,361}362impl ExprFunction {363	pub fn function_token(&self) -> Option<SyntaxToken> {364		support::token(&self.syntax, T![function])365	}366	pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }367	pub fn params_desc(&self) -> Option<ParamsDesc> { support::child(&self.syntax) }368	pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }369	pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }370}371372#[derive(Debug, Clone, PartialEq, Eq, Hash)]373pub struct ParamsDesc {374	pub(crate) syntax: SyntaxNode,375}376impl ParamsDesc {377	pub fn params(&self) -> AstChildren<Param> { support::children(&self.syntax) }378}379380#[derive(Debug, Clone, PartialEq, Eq, Hash)]381pub struct ExprAssert {382	pub(crate) syntax: SyntaxNode,383}384impl ExprAssert {385	pub fn assertion(&self) -> Option<Assertion> { support::child(&self.syntax) }386	pub fn semi_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }387	pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }388}389390#[derive(Debug, Clone, PartialEq, Eq, Hash)]391pub struct Assertion {392	pub(crate) syntax: SyntaxNode,393}394impl Assertion {395	pub fn assert_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![assert]) }396	pub fn condition(&self) -> Option<Expr> { support::child(&self.syntax) }397	pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }398	pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }399}400401#[derive(Debug, Clone, PartialEq, Eq, Hash)]402pub struct ExprError {403	pub(crate) syntax: SyntaxNode,404}405impl ExprError {406	pub fn error_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![error]) }407	pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }408}409410#[derive(Debug, Clone, PartialEq, Eq, Hash)]411pub struct Arg {412	pub(crate) syntax: SyntaxNode,413}414impl Arg {415	pub fn name(&self) -> Option<Name> { support::child(&self.syntax) }416	pub fn assign_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }417	pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }418}419420#[derive(Debug, Clone, PartialEq, Eq, Hash)]421pub struct ObjBodyComp {422	pub(crate) syntax: SyntaxNode,423}424impl ObjBodyComp {425	pub fn pre(&self) -> AstChildren<ObjLocalPostComma> { support::children(&self.syntax) }426	pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }427	pub fn key(&self) -> Option<Expr> { support::child(&self.syntax) }428	pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }429	pub fn plus_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![+]) }430	pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }431	pub fn value(&self) -> Option<Expr> { support::child(&self.syntax) }432	pub fn post(&self) -> AstChildren<ObjLocalPreComma> { support::children(&self.syntax) }433	pub fn for_spec(&self) -> Option<ForSpec> { support::child(&self.syntax) }434	pub fn comp_specs(&self) -> AstChildren<CompSpec> { support::children(&self.syntax) }435}436437#[derive(Debug, Clone, PartialEq, Eq, Hash)]438pub struct ObjLocalPostComma {439	pub(crate) syntax: SyntaxNode,440}441impl ObjLocalPostComma {442	pub fn obj_local(&self) -> Option<ObjLocal> { support::child(&self.syntax) }443	pub fn comma_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![,]) }444}445446#[derive(Debug, Clone, PartialEq, Eq, Hash)]447pub struct ObjLocalPreComma {448	pub(crate) syntax: SyntaxNode,449}450impl ObjLocalPreComma {451	pub fn comma_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![,]) }452	pub fn obj_local(&self) -> Option<ObjLocal> { support::child(&self.syntax) }453}454455#[derive(Debug, Clone, PartialEq, Eq, Hash)]456pub struct ObjBodyMemberList {457	pub(crate) syntax: SyntaxNode,458}459impl ObjBodyMemberList {460	pub fn member(&self) -> Option<Member> { support::child(&self.syntax) }461	pub fn comma_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![,]) }462}463464#[derive(Debug, Clone, PartialEq, Eq, Hash)]465pub struct ObjLocal {466	pub(crate) syntax: SyntaxNode,467}468impl ObjLocal {469	pub fn local_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![local]) }470	pub fn bind(&self) -> Option<Bind> { support::child(&self.syntax) }471}472473#[derive(Debug, Clone, PartialEq, Eq, Hash)]474pub struct MemberBindStmt {475	pub(crate) syntax: SyntaxNode,476}477impl MemberBindStmt {478	pub fn obj_local(&self) -> Option<ObjLocal> { support::child(&self.syntax) }479}480481#[derive(Debug, Clone, PartialEq, Eq, Hash)]482pub struct MemberAssertStmt {483	pub(crate) syntax: SyntaxNode,484}485impl MemberAssertStmt {486	pub fn assertion(&self) -> Option<Assertion> { support::child(&self.syntax) }487}488489#[derive(Debug, Clone, PartialEq, Eq, Hash)]490pub struct MemberField {491	pub(crate) syntax: SyntaxNode,492}493impl MemberField {494	pub fn field(&self) -> Option<Field> { support::child(&self.syntax) }495}496497#[derive(Debug, Clone, PartialEq, Eq, Hash)]498pub struct FieldNormal {499	pub(crate) syntax: SyntaxNode,500}501impl FieldNormal {502	pub fn field_name(&self) -> Option<FieldName> { support::child(&self.syntax) }503	pub fn plus_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![+]) }504	pub fn visibility(&self) -> Option<Visibility> { support::child(&self.syntax) }505	pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }506}507508#[derive(Debug, Clone, PartialEq, Eq, Hash)]509pub struct Visibility {510	pub(crate) syntax: SyntaxNode,511}512impl Visibility {513	pub fn coloncoloncolon_token(&self) -> Option<SyntaxToken> {514		support::token(&self.syntax, T![:::])515	}516	pub fn coloncolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![::]) }517	pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }518}519520#[derive(Debug, Clone, PartialEq, Eq, Hash)]521pub struct FieldMethod {522	pub(crate) syntax: SyntaxNode,523}524impl FieldMethod {525	pub fn field_name(&self) -> Option<FieldName> { support::child(&self.syntax) }526	pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }527	pub fn params_desc(&self) -> Option<ParamsDesc> { support::child(&self.syntax) }528	pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }529	pub fn visibility(&self) -> Option<Visibility> { support::child(&self.syntax) }530	pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }531}532533#[derive(Debug, Clone, PartialEq, Eq, Hash)]534pub struct FieldNameFixed {535	pub(crate) syntax: SyntaxNode,536}537impl FieldNameFixed {538	pub fn id(&self) -> Option<Name> { support::child(&self.syntax) }539	pub fn string(&self) -> Option<String> { support::child(&self.syntax) }540}541542#[derive(Debug, Clone, PartialEq, Eq, Hash)]543pub struct FieldNameDynamic {544	pub(crate) syntax: SyntaxNode,545}546impl FieldNameDynamic {547	pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }548	pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }549	pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }550}551552#[derive(Debug, Clone, PartialEq, Eq, Hash)]553pub struct IfSpec {554	pub(crate) syntax: SyntaxNode,555}556impl IfSpec {557	pub fn if_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![if]) }558	pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }559}560561#[derive(Debug, Clone, PartialEq, Eq, Hash)]562pub struct BindDestruct {563	pub(crate) syntax: SyntaxNode,564}565impl BindDestruct {566	pub fn into(&self) -> Option<Destruct> { support::child(&self.syntax) }567	pub fn assign_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }568	pub fn value(&self) -> Option<Expr> { support::child(&self.syntax) }569}570571#[derive(Debug, Clone, PartialEq, Eq, Hash)]572pub struct Destruct {573	pub(crate) syntax: SyntaxNode,574}575impl Destruct {576	pub fn destruct_full(&self) -> Option<DestructFull> { support::child(&self.syntax) }577	pub fn destruct_skip(&self) -> Option<DestructSkip> { support::child(&self.syntax) }578	pub fn destruct_array(&self) -> Option<DestructArray> { support::child(&self.syntax) }579	pub fn destruct_object(&self) -> Option<DestructObject> { support::child(&self.syntax) }580}581582#[derive(Debug, Clone, PartialEq, Eq, Hash)]583pub struct BindFunction {584	pub(crate) syntax: SyntaxNode,585}586impl BindFunction {587	pub fn name(&self) -> Option<Name> { support::child(&self.syntax) }588	pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }589	pub fn params(&self) -> Option<ParamsDesc> { support::child(&self.syntax) }590	pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }591	pub fn assign_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }592	pub fn value(&self) -> Option<Expr> { support::child(&self.syntax) }593}594595#[derive(Debug, Clone, PartialEq, Eq, Hash)]596pub struct Param {597	pub(crate) syntax: SyntaxNode,598}599impl Param {600	pub fn destruct(&self) -> Option<Destruct> { support::child(&self.syntax) }601	pub fn assign_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }602	pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }603}604605#[derive(Debug, Clone, PartialEq, Eq, Hash)]606pub struct DestructFull {607	pub(crate) syntax: SyntaxNode,608}609impl DestructFull {610	pub fn into(&self) -> Option<Name> { support::child(&self.syntax) }611}612613#[derive(Debug, Clone, PartialEq, Eq, Hash)]614pub struct DestructSkip {615	pub(crate) syntax: SyntaxNode,616}617impl DestructSkip {618	pub fn question_mark_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![?]) }619}620621#[derive(Debug, Clone, PartialEq, Eq, Hash)]622pub struct DestructArray {623	pub(crate) syntax: SyntaxNode,624}625impl DestructArray {626	pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }627	pub fn start(&self) -> AstChildren<Destruct> { support::children(&self.syntax) }628	pub fn destruct_rest(&self) -> Option<DestructRest> { support::child(&self.syntax) }629	pub fn comma_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![,]) }630	pub fn end(&self) -> AstChildren<Destruct> { support::children(&self.syntax) }631	pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }632}633634#[derive(Debug, Clone, PartialEq, Eq, Hash)]635pub struct DestructRest {636	pub(crate) syntax: SyntaxNode,637}638impl DestructRest {639	pub fn dotdotdot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![...]) }640	pub fn into(&self) -> Option<Name> { support::child(&self.syntax) }641}642643#[derive(Debug, Clone, PartialEq, Eq, Hash)]644pub struct DestructObject {645	pub(crate) syntax: SyntaxNode,646}647impl DestructObject {648	pub fn l_brace_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }649	pub fn destruct_object_fields(&self) -> AstChildren<DestructObjectField> {650		support::children(&self.syntax)651	}652	pub fn destruct_rest(&self) -> Option<DestructRest> { support::child(&self.syntax) }653	pub fn comma_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![,]) }654	pub fn r_brace_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }655}656657#[derive(Debug, Clone, PartialEq, Eq, Hash)]658pub struct DestructObjectField {659	pub(crate) syntax: SyntaxNode,660}661impl DestructObjectField {662	pub fn field(&self) -> Option<Name> { support::child(&self.syntax) }663	pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }664	pub fn destruct(&self) -> Option<Destruct> { support::child(&self.syntax) }665	pub fn assign_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }666	pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }667}668669#[derive(Debug, Clone, PartialEq, Eq, Hash)]670pub enum Expr {671	ExprBinary(ExprBinary),672	ExprUnary(ExprUnary),673	ExprSlice(ExprSlice),674	ExprIndex(ExprIndex),675	ExprIndexExpr(ExprIndexExpr),676	ExprApply(ExprApply),677	ExprObjExtend(ExprObjExtend),678	ExprParened(ExprParened),679	ExprIntrinsicThisFile(ExprIntrinsicThisFile),680	ExprIntrinsicId(ExprIntrinsicId),681	ExprIntrinsic(ExprIntrinsic),682	ExprString(ExprString),683	ExprNumber(ExprNumber),684	ExprArray(ExprArray),685	ExprObject(ExprObject),686	ExprArrayComp(ExprArrayComp),687	ExprImport(ExprImport),688	ExprVar(ExprVar),689	ExprLocal(ExprLocal),690	ExprIfThenElse(ExprIfThenElse),691	ExprFunction(ExprFunction),692	ExprAssert(ExprAssert),693	ExprError(ExprError),694}695696#[derive(Debug, Clone, PartialEq, Eq, Hash)]697pub enum ObjBody {698	ObjBodyComp(ObjBodyComp),699	ObjBodyMemberList(ObjBodyMemberList),700}701702#[derive(Debug, Clone, PartialEq, Eq, Hash)]703pub enum CompSpec {704	ForSpec(ForSpec),705	IfSpec(IfSpec),706}707708#[derive(Debug, Clone, PartialEq, Eq, Hash)]709pub enum Bind {710	BindDestruct(BindDestruct),711	BindFunction(BindFunction),712}713714#[derive(Debug, Clone, PartialEq, Eq, Hash)]715pub enum Member {716	MemberBindStmt(MemberBindStmt),717	MemberAssertStmt(MemberAssertStmt),718	MemberField(MemberField),719}720721#[derive(Debug, Clone, PartialEq, Eq, Hash)]722pub enum Field {723	FieldNormal(FieldNormal),724	FieldMethod(FieldMethod),725}726727#[derive(Debug, Clone, PartialEq, Eq, Hash)]728pub enum FieldName {729	FieldNameFixed(FieldNameFixed),730	FieldNameDynamic(FieldNameDynamic),731}732impl AstNode for SourceFile {733	fn can_cast(kind: SyntaxKind) -> bool { kind == SOURCE_FILE }734	fn cast(syntax: SyntaxNode) -> Option<Self> {735		if Self::can_cast(syntax.kind()) {736			Some(Self { syntax })737		} else {738			None739		}740	}741	fn syntax(&self) -> &SyntaxNode { &self.syntax }742}743impl AstNode for ExprBinary {744	fn can_cast(kind: SyntaxKind) -> bool { kind == EXPR_BINARY }745	fn cast(syntax: SyntaxNode) -> Option<Self> {746		if Self::can_cast(syntax.kind()) {747			Some(Self { syntax })748		} else {749			None750		}751	}752	fn syntax(&self) -> &SyntaxNode { &self.syntax }753}754impl AstNode for BinaryOperator {755	fn can_cast(kind: SyntaxKind) -> bool { kind == BINARY_OPERATOR }756	fn cast(syntax: SyntaxNode) -> Option<Self> {757		if Self::can_cast(syntax.kind()) {758			Some(Self { syntax })759		} else {760			None761		}762	}763	fn syntax(&self) -> &SyntaxNode { &self.syntax }764}765impl AstNode for ExprUnary {766	fn can_cast(kind: SyntaxKind) -> bool { kind == EXPR_UNARY }767	fn cast(syntax: SyntaxNode) -> Option<Self> {768		if Self::can_cast(syntax.kind()) {769			Some(Self { syntax })770		} else {771			None772		}773	}774	fn syntax(&self) -> &SyntaxNode { &self.syntax }775}776impl AstNode for UnaryOperator {777	fn can_cast(kind: SyntaxKind) -> bool { kind == UNARY_OPERATOR }778	fn cast(syntax: SyntaxNode) -> Option<Self> {779		if Self::can_cast(syntax.kind()) {780			Some(Self { syntax })781		} else {782			None783		}784	}785	fn syntax(&self) -> &SyntaxNode { &self.syntax }786}787impl AstNode for ExprSlice {788	fn can_cast(kind: SyntaxKind) -> bool { kind == EXPR_SLICE }789	fn cast(syntax: SyntaxNode) -> Option<Self> {790		if Self::can_cast(syntax.kind()) {791			Some(Self { syntax })792		} else {793			None794		}795	}796	fn syntax(&self) -> &SyntaxNode { &self.syntax }797}798impl AstNode for SliceDesc {799	fn can_cast(kind: SyntaxKind) -> bool { kind == SLICE_DESC }800	fn cast(syntax: SyntaxNode) -> Option<Self> {801		if Self::can_cast(syntax.kind()) {802			Some(Self { syntax })803		} else {804			None805		}806	}807	fn syntax(&self) -> &SyntaxNode { &self.syntax }808}809impl AstNode for ExprIndex {810	fn can_cast(kind: SyntaxKind) -> bool { kind == EXPR_INDEX }811	fn cast(syntax: SyntaxNode) -> Option<Self> {812		if Self::can_cast(syntax.kind()) {813			Some(Self { syntax })814		} else {815			None816		}817	}818	fn syntax(&self) -> &SyntaxNode { &self.syntax }819}820impl AstNode for Name {821	fn can_cast(kind: SyntaxKind) -> bool { kind == NAME }822	fn cast(syntax: SyntaxNode) -> Option<Self> {823		if Self::can_cast(syntax.kind()) {824			Some(Self { syntax })825		} else {826			None827		}828	}829	fn syntax(&self) -> &SyntaxNode { &self.syntax }830}831impl AstNode for ExprIndexExpr {832	fn can_cast(kind: SyntaxKind) -> bool { kind == EXPR_INDEX_EXPR }833	fn cast(syntax: SyntaxNode) -> Option<Self> {834		if Self::can_cast(syntax.kind()) {835			Some(Self { syntax })836		} else {837			None838		}839	}840	fn syntax(&self) -> &SyntaxNode { &self.syntax }841}842impl AstNode for ExprApply {843	fn can_cast(kind: SyntaxKind) -> bool { kind == EXPR_APPLY }844	fn cast(syntax: SyntaxNode) -> Option<Self> {845		if Self::can_cast(syntax.kind()) {846			Some(Self { syntax })847		} else {848			None849		}850	}851	fn syntax(&self) -> &SyntaxNode { &self.syntax }852}853impl AstNode for ArgsDesc {854	fn can_cast(kind: SyntaxKind) -> bool { kind == ARGS_DESC }855	fn cast(syntax: SyntaxNode) -> Option<Self> {856		if Self::can_cast(syntax.kind()) {857			Some(Self { syntax })858		} else {859			None860		}861	}862	fn syntax(&self) -> &SyntaxNode { &self.syntax }863}864impl AstNode for ExprObjExtend {865	fn can_cast(kind: SyntaxKind) -> bool { kind == EXPR_OBJ_EXTEND }866	fn cast(syntax: SyntaxNode) -> Option<Self> {867		if Self::can_cast(syntax.kind()) {868			Some(Self { syntax })869		} else {870			None871		}872	}873	fn syntax(&self) -> &SyntaxNode { &self.syntax }874}875impl AstNode for ExprParened {876	fn can_cast(kind: SyntaxKind) -> bool { kind == EXPR_PARENED }877	fn cast(syntax: SyntaxNode) -> Option<Self> {878		if Self::can_cast(syntax.kind()) {879			Some(Self { syntax })880		} else {881			None882		}883	}884	fn syntax(&self) -> &SyntaxNode { &self.syntax }885}886impl AstNode for ExprLiteral {887	fn can_cast(kind: SyntaxKind) -> bool { kind == EXPR_LITERAL }888	fn cast(syntax: SyntaxNode) -> Option<Self> {889		if Self::can_cast(syntax.kind()) {890			Some(Self { syntax })891		} else {892			None893		}894	}895	fn syntax(&self) -> &SyntaxNode { &self.syntax }896}897impl AstNode for Literal {898	fn can_cast(kind: SyntaxKind) -> bool { kind == LITERAL }899	fn cast(syntax: SyntaxNode) -> Option<Self> {900		if Self::can_cast(syntax.kind()) {901			Some(Self { syntax })902		} else {903			None904		}905	}906	fn syntax(&self) -> &SyntaxNode { &self.syntax }907}908impl AstNode for ExprIntrinsicThisFile {909	fn can_cast(kind: SyntaxKind) -> bool { kind == EXPR_INTRINSIC_THIS_FILE }910	fn cast(syntax: SyntaxNode) -> Option<Self> {911		if Self::can_cast(syntax.kind()) {912			Some(Self { syntax })913		} else {914			None915		}916	}917	fn syntax(&self) -> &SyntaxNode { &self.syntax }918}919impl AstNode for ExprIntrinsicId {920	fn can_cast(kind: SyntaxKind) -> bool { kind == EXPR_INTRINSIC_ID }921	fn cast(syntax: SyntaxNode) -> Option<Self> {922		if Self::can_cast(syntax.kind()) {923			Some(Self { syntax })924		} else {925			None926		}927	}928	fn syntax(&self) -> &SyntaxNode { &self.syntax }929}930impl AstNode for ExprIntrinsic {931	fn can_cast(kind: SyntaxKind) -> bool { kind == EXPR_INTRINSIC }932	fn cast(syntax: SyntaxNode) -> Option<Self> {933		if Self::can_cast(syntax.kind()) {934			Some(Self { syntax })935		} else {936			None937		}938	}939	fn syntax(&self) -> &SyntaxNode { &self.syntax }940}941impl AstNode for ExprString {942	fn can_cast(kind: SyntaxKind) -> bool { kind == EXPR_STRING }943	fn cast(syntax: SyntaxNode) -> Option<Self> {944		if Self::can_cast(syntax.kind()) {945			Some(Self { syntax })946		} else {947			None948		}949	}950	fn syntax(&self) -> &SyntaxNode { &self.syntax }951}952impl AstNode for String {953	fn can_cast(kind: SyntaxKind) -> bool { kind == STRING }954	fn cast(syntax: SyntaxNode) -> Option<Self> {955		if Self::can_cast(syntax.kind()) {956			Some(Self { syntax })957		} else {958			None959		}960	}961	fn syntax(&self) -> &SyntaxNode { &self.syntax }962}963impl AstNode for ExprNumber {964	fn can_cast(kind: SyntaxKind) -> bool { kind == EXPR_NUMBER }965	fn cast(syntax: SyntaxNode) -> Option<Self> {966		if Self::can_cast(syntax.kind()) {967			Some(Self { syntax })968		} else {969			None970		}971	}972	fn syntax(&self) -> &SyntaxNode { &self.syntax }973}974impl AstNode for Number {975	fn can_cast(kind: SyntaxKind) -> bool { kind == NUMBER }976	fn cast(syntax: SyntaxNode) -> Option<Self> {977		if Self::can_cast(syntax.kind()) {978			Some(Self { syntax })979		} else {980			None981		}982	}983	fn syntax(&self) -> &SyntaxNode { &self.syntax }984}985impl AstNode for ExprArray {986	fn can_cast(kind: SyntaxKind) -> bool { kind == EXPR_ARRAY }987	fn cast(syntax: SyntaxNode) -> Option<Self> {988		if Self::can_cast(syntax.kind()) {989			Some(Self { syntax })990		} else {991			None992		}993	}994	fn syntax(&self) -> &SyntaxNode { &self.syntax }995}996impl AstNode for ExprObject {997	fn can_cast(kind: SyntaxKind) -> bool { kind == EXPR_OBJECT }998	fn cast(syntax: SyntaxNode) -> Option<Self> {999		if Self::can_cast(syntax.kind()) {1000			Some(Self { syntax })1001		} else {1002			None1003		}1004	}1005	fn syntax(&self) -> &SyntaxNode { &self.syntax }1006}1007impl AstNode for ExprArrayComp {1008	fn can_cast(kind: SyntaxKind) -> bool { kind == EXPR_ARRAY_COMP }1009	fn cast(syntax: SyntaxNode) -> Option<Self> {1010		if Self::can_cast(syntax.kind()) {1011			Some(Self { syntax })1012		} else {1013			None1014		}1015	}1016	fn syntax(&self) -> &SyntaxNode { &self.syntax }1017}1018impl AstNode for ForSpec {1019	fn can_cast(kind: SyntaxKind) -> bool { kind == FOR_SPEC }1020	fn cast(syntax: SyntaxNode) -> Option<Self> {1021		if Self::can_cast(syntax.kind()) {1022			Some(Self { syntax })1023		} else {1024			None1025		}1026	}1027	fn syntax(&self) -> &SyntaxNode { &self.syntax }1028}1029impl AstNode for ExprImport {1030	fn can_cast(kind: SyntaxKind) -> bool { kind == EXPR_IMPORT }1031	fn cast(syntax: SyntaxNode) -> Option<Self> {1032		if Self::can_cast(syntax.kind()) {1033			Some(Self { syntax })1034		} else {1035			None1036		}1037	}1038	fn syntax(&self) -> &SyntaxNode { &self.syntax }1039}1040impl AstNode for ExprVar {1041	fn can_cast(kind: SyntaxKind) -> bool { kind == EXPR_VAR }1042	fn cast(syntax: SyntaxNode) -> Option<Self> {1043		if Self::can_cast(syntax.kind()) {1044			Some(Self { syntax })1045		} else {1046			None1047		}1048	}1049	fn syntax(&self) -> &SyntaxNode { &self.syntax }1050}1051impl AstNode for ExprLocal {1052	fn can_cast(kind: SyntaxKind) -> bool { kind == EXPR_LOCAL }1053	fn cast(syntax: SyntaxNode) -> Option<Self> {1054		if Self::can_cast(syntax.kind()) {1055			Some(Self { syntax })1056		} else {1057			None1058		}1059	}1060	fn syntax(&self) -> &SyntaxNode { &self.syntax }1061}1062impl AstNode for ExprIfThenElse {1063	fn can_cast(kind: SyntaxKind) -> bool { kind == EXPR_IF_THEN_ELSE }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 { &self.syntax }1072}1073impl AstNode for ExprFunction {1074	fn can_cast(kind: SyntaxKind) -> bool { kind == EXPR_FUNCTION }1075	fn cast(syntax: SyntaxNode) -> Option<Self> {1076		if Self::can_cast(syntax.kind()) {1077			Some(Self { syntax })1078		} else {1079			None1080		}1081	}1082	fn syntax(&self) -> &SyntaxNode { &self.syntax }1083}1084impl AstNode for ParamsDesc {1085	fn can_cast(kind: SyntaxKind) -> bool { kind == PARAMS_DESC }1086	fn cast(syntax: SyntaxNode) -> Option<Self> {1087		if Self::can_cast(syntax.kind()) {1088			Some(Self { syntax })1089		} else {1090			None1091		}1092	}1093	fn syntax(&self) -> &SyntaxNode { &self.syntax }1094}1095impl AstNode for ExprAssert {1096	fn can_cast(kind: SyntaxKind) -> bool { kind == EXPR_ASSERT }1097	fn cast(syntax: SyntaxNode) -> Option<Self> {1098		if Self::can_cast(syntax.kind()) {1099			Some(Self { syntax })1100		} else {1101			None1102		}1103	}1104	fn syntax(&self) -> &SyntaxNode { &self.syntax }1105}1106impl AstNode for Assertion {1107	fn can_cast(kind: SyntaxKind) -> bool { kind == ASSERTION }1108	fn cast(syntax: SyntaxNode) -> Option<Self> {1109		if Self::can_cast(syntax.kind()) {1110			Some(Self { syntax })1111		} else {1112			None1113		}1114	}1115	fn syntax(&self) -> &SyntaxNode { &self.syntax }1116}1117impl AstNode for ExprError {1118	fn can_cast(kind: SyntaxKind) -> bool { kind == EXPR_ERROR }1119	fn cast(syntax: SyntaxNode) -> Option<Self> {1120		if Self::can_cast(syntax.kind()) {1121			Some(Self { syntax })1122		} else {1123			None1124		}1125	}1126	fn syntax(&self) -> &SyntaxNode { &self.syntax }1127}1128impl AstNode for Arg {1129	fn can_cast(kind: SyntaxKind) -> bool { kind == ARG }1130	fn cast(syntax: SyntaxNode) -> Option<Self> {1131		if Self::can_cast(syntax.kind()) {1132			Some(Self { syntax })1133		} else {1134			None1135		}1136	}1137	fn syntax(&self) -> &SyntaxNode { &self.syntax }1138}1139impl AstNode for ObjBodyComp {1140	fn can_cast(kind: SyntaxKind) -> bool { kind == OBJ_BODY_COMP }1141	fn cast(syntax: SyntaxNode) -> Option<Self> {1142		if Self::can_cast(syntax.kind()) {1143			Some(Self { syntax })1144		} else {1145			None1146		}1147	}1148	fn syntax(&self) -> &SyntaxNode { &self.syntax }1149}1150impl AstNode for ObjLocalPostComma {1151	fn can_cast(kind: SyntaxKind) -> bool { kind == OBJ_LOCAL_POST_COMMA }1152	fn cast(syntax: SyntaxNode) -> Option<Self> {1153		if Self::can_cast(syntax.kind()) {1154			Some(Self { syntax })1155		} else {1156			None1157		}1158	}1159	fn syntax(&self) -> &SyntaxNode { &self.syntax }1160}1161impl AstNode for ObjLocalPreComma {1162	fn can_cast(kind: SyntaxKind) -> bool { kind == OBJ_LOCAL_PRE_COMMA }1163	fn cast(syntax: SyntaxNode) -> Option<Self> {1164		if Self::can_cast(syntax.kind()) {1165			Some(Self { syntax })1166		} else {1167			None1168		}1169	}1170	fn syntax(&self) -> &SyntaxNode { &self.syntax }1171}1172impl AstNode for ObjBodyMemberList {1173	fn can_cast(kind: SyntaxKind) -> bool { kind == OBJ_BODY_MEMBER_LIST }1174	fn cast(syntax: SyntaxNode) -> Option<Self> {1175		if Self::can_cast(syntax.kind()) {1176			Some(Self { syntax })1177		} else {1178			None1179		}1180	}1181	fn syntax(&self) -> &SyntaxNode { &self.syntax }1182}1183impl AstNode for ObjLocal {1184	fn can_cast(kind: SyntaxKind) -> bool { kind == OBJ_LOCAL }1185	fn cast(syntax: SyntaxNode) -> Option<Self> {1186		if Self::can_cast(syntax.kind()) {1187			Some(Self { syntax })1188		} else {1189			None1190		}1191	}1192	fn syntax(&self) -> &SyntaxNode { &self.syntax }1193}1194impl AstNode for MemberBindStmt {1195	fn can_cast(kind: SyntaxKind) -> bool { kind == MEMBER_BIND_STMT }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 { &self.syntax }1204}1205impl AstNode for MemberAssertStmt {1206	fn can_cast(kind: SyntaxKind) -> bool { kind == MEMBER_ASSERT_STMT }1207	fn cast(syntax: SyntaxNode) -> Option<Self> {1208		if Self::can_cast(syntax.kind()) {1209			Some(Self { syntax })1210		} else {1211			None1212		}1213	}1214	fn syntax(&self) -> &SyntaxNode { &self.syntax }1215}1216impl AstNode for MemberField {1217	fn can_cast(kind: SyntaxKind) -> bool { kind == MEMBER_FIELD }1218	fn cast(syntax: SyntaxNode) -> Option<Self> {1219		if Self::can_cast(syntax.kind()) {1220			Some(Self { syntax })1221		} else {1222			None1223		}1224	}1225	fn syntax(&self) -> &SyntaxNode { &self.syntax }1226}1227impl AstNode for FieldNormal {1228	fn can_cast(kind: SyntaxKind) -> bool { kind == FIELD_NORMAL }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 { &self.syntax }1237}1238impl AstNode for Visibility {1239	fn can_cast(kind: SyntaxKind) -> bool { kind == VISIBILITY }1240	fn cast(syntax: SyntaxNode) -> Option<Self> {1241		if Self::can_cast(syntax.kind()) {1242			Some(Self { syntax })1243		} else {1244			None1245		}1246	}1247	fn syntax(&self) -> &SyntaxNode { &self.syntax }1248}1249impl AstNode for FieldMethod {1250	fn can_cast(kind: SyntaxKind) -> bool { kind == FIELD_METHOD }1251	fn cast(syntax: SyntaxNode) -> Option<Self> {1252		if Self::can_cast(syntax.kind()) {1253			Some(Self { syntax })1254		} else {1255			None1256		}1257	}1258	fn syntax(&self) -> &SyntaxNode { &self.syntax }1259}1260impl AstNode for FieldNameFixed {1261	fn can_cast(kind: SyntaxKind) -> bool { kind == FIELD_NAME_FIXED }1262	fn cast(syntax: SyntaxNode) -> Option<Self> {1263		if Self::can_cast(syntax.kind()) {1264			Some(Self { syntax })1265		} else {1266			None1267		}1268	}1269	fn syntax(&self) -> &SyntaxNode { &self.syntax }1270}1271impl AstNode for FieldNameDynamic {1272	fn can_cast(kind: SyntaxKind) -> bool { kind == FIELD_NAME_DYNAMIC }1273	fn cast(syntax: SyntaxNode) -> Option<Self> {1274		if Self::can_cast(syntax.kind()) {1275			Some(Self { syntax })1276		} else {1277			None1278		}1279	}1280	fn syntax(&self) -> &SyntaxNode { &self.syntax }1281}1282impl AstNode for IfSpec {1283	fn can_cast(kind: SyntaxKind) -> bool { kind == IF_SPEC }1284	fn cast(syntax: SyntaxNode) -> Option<Self> {1285		if Self::can_cast(syntax.kind()) {1286			Some(Self { syntax })1287		} else {1288			None1289		}1290	}1291	fn syntax(&self) -> &SyntaxNode { &self.syntax }1292}1293impl AstNode for BindDestruct {1294	fn can_cast(kind: SyntaxKind) -> bool { kind == BIND_DESTRUCT }1295	fn cast(syntax: SyntaxNode) -> Option<Self> {1296		if Self::can_cast(syntax.kind()) {1297			Some(Self { syntax })1298		} else {1299			None1300		}1301	}1302	fn syntax(&self) -> &SyntaxNode { &self.syntax }1303}1304impl AstNode for Destruct {1305	fn can_cast(kind: SyntaxKind) -> bool { kind == DESTRUCT }1306	fn cast(syntax: SyntaxNode) -> Option<Self> {1307		if Self::can_cast(syntax.kind()) {1308			Some(Self { syntax })1309		} else {1310			None1311		}1312	}1313	fn syntax(&self) -> &SyntaxNode { &self.syntax }1314}1315impl AstNode for BindFunction {1316	fn can_cast(kind: SyntaxKind) -> bool { kind == BIND_FUNCTION }1317	fn cast(syntax: SyntaxNode) -> Option<Self> {1318		if Self::can_cast(syntax.kind()) {1319			Some(Self { syntax })1320		} else {1321			None1322		}1323	}1324	fn syntax(&self) -> &SyntaxNode { &self.syntax }1325}1326impl AstNode for Param {1327	fn can_cast(kind: SyntaxKind) -> bool { kind == PARAM }1328	fn cast(syntax: SyntaxNode) -> Option<Self> {1329		if Self::can_cast(syntax.kind()) {1330			Some(Self { syntax })1331		} else {1332			None1333		}1334	}1335	fn syntax(&self) -> &SyntaxNode { &self.syntax }1336}1337impl AstNode for DestructFull {1338	fn can_cast(kind: SyntaxKind) -> bool { kind == DESTRUCT_FULL }1339	fn cast(syntax: SyntaxNode) -> Option<Self> {1340		if Self::can_cast(syntax.kind()) {1341			Some(Self { syntax })1342		} else {1343			None1344		}1345	}1346	fn syntax(&self) -> &SyntaxNode { &self.syntax }1347}1348impl AstNode for DestructSkip {1349	fn can_cast(kind: SyntaxKind) -> bool { kind == DESTRUCT_SKIP }1350	fn cast(syntax: SyntaxNode) -> Option<Self> {1351		if Self::can_cast(syntax.kind()) {1352			Some(Self { syntax })1353		} else {1354			None1355		}1356	}1357	fn syntax(&self) -> &SyntaxNode { &self.syntax }1358}1359impl AstNode for DestructArray {1360	fn can_cast(kind: SyntaxKind) -> bool { kind == DESTRUCT_ARRAY }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 { &self.syntax }1369}1370impl AstNode for DestructRest {1371	fn can_cast(kind: SyntaxKind) -> bool { kind == DESTRUCT_REST }1372	fn cast(syntax: SyntaxNode) -> Option<Self> {1373		if Self::can_cast(syntax.kind()) {1374			Some(Self { syntax })1375		} else {1376			None1377		}1378	}1379	fn syntax(&self) -> &SyntaxNode { &self.syntax }1380}1381impl AstNode for DestructObject {1382	fn can_cast(kind: SyntaxKind) -> bool { kind == DESTRUCT_OBJECT }1383	fn cast(syntax: SyntaxNode) -> Option<Self> {1384		if Self::can_cast(syntax.kind()) {1385			Some(Self { syntax })1386		} else {1387			None1388		}1389	}1390	fn syntax(&self) -> &SyntaxNode { &self.syntax }1391}1392impl AstNode for DestructObjectField {1393	fn can_cast(kind: SyntaxKind) -> bool { kind == DESTRUCT_OBJECT_FIELD }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 { &self.syntax }1402}1403impl From<ExprBinary> for Expr {1404	fn from(node: ExprBinary) -> Expr { Expr::ExprBinary(node) }1405}1406impl From<ExprUnary> for Expr {1407	fn from(node: ExprUnary) -> Expr { Expr::ExprUnary(node) }1408}1409impl From<ExprSlice> for Expr {1410	fn from(node: ExprSlice) -> Expr { Expr::ExprSlice(node) }1411}1412impl From<ExprIndex> for Expr {1413	fn from(node: ExprIndex) -> Expr { Expr::ExprIndex(node) }1414}1415impl From<ExprIndexExpr> for Expr {1416	fn from(node: ExprIndexExpr) -> Expr { Expr::ExprIndexExpr(node) }1417}1418impl From<ExprApply> for Expr {1419	fn from(node: ExprApply) -> Expr { Expr::ExprApply(node) }1420}1421impl From<ExprObjExtend> for Expr {1422	fn from(node: ExprObjExtend) -> Expr { Expr::ExprObjExtend(node) }1423}1424impl From<ExprParened> for Expr {1425	fn from(node: ExprParened) -> Expr { Expr::ExprParened(node) }1426}1427impl From<ExprIntrinsicThisFile> for Expr {1428	fn from(node: ExprIntrinsicThisFile) -> Expr { Expr::ExprIntrinsicThisFile(node) }1429}1430impl From<ExprIntrinsicId> for Expr {1431	fn from(node: ExprIntrinsicId) -> Expr { Expr::ExprIntrinsicId(node) }1432}1433impl From<ExprIntrinsic> for Expr {1434	fn from(node: ExprIntrinsic) -> Expr { Expr::ExprIntrinsic(node) }1435}1436impl From<ExprString> for Expr {1437	fn from(node: ExprString) -> Expr { Expr::ExprString(node) }1438}1439impl From<ExprNumber> for Expr {1440	fn from(node: ExprNumber) -> Expr { Expr::ExprNumber(node) }1441}1442impl From<ExprArray> for Expr {1443	fn from(node: ExprArray) -> Expr { Expr::ExprArray(node) }1444}1445impl From<ExprObject> for Expr {1446	fn from(node: ExprObject) -> Expr { Expr::ExprObject(node) }1447}1448impl From<ExprArrayComp> for Expr {1449	fn from(node: ExprArrayComp) -> Expr { Expr::ExprArrayComp(node) }1450}1451impl From<ExprImport> for Expr {1452	fn from(node: ExprImport) -> Expr { Expr::ExprImport(node) }1453}1454impl From<ExprVar> for Expr {1455	fn from(node: ExprVar) -> Expr { Expr::ExprVar(node) }1456}1457impl From<ExprLocal> for Expr {1458	fn from(node: ExprLocal) -> Expr { Expr::ExprLocal(node) }1459}1460impl From<ExprIfThenElse> for Expr {1461	fn from(node: ExprIfThenElse) -> Expr { Expr::ExprIfThenElse(node) }1462}1463impl From<ExprFunction> for Expr {1464	fn from(node: ExprFunction) -> Expr { Expr::ExprFunction(node) }1465}1466impl From<ExprAssert> for Expr {1467	fn from(node: ExprAssert) -> Expr { Expr::ExprAssert(node) }1468}1469impl From<ExprError> for Expr {1470	fn from(node: ExprError) -> Expr { Expr::ExprError(node) }1471}1472impl AstNode for Expr {1473	fn can_cast(kind: SyntaxKind) -> bool {1474		match kind {1475			EXPR_BINARY1476			| EXPR_UNARY1477			| EXPR_SLICE1478			| EXPR_INDEX1479			| EXPR_INDEX_EXPR1480			| EXPR_APPLY1481			| EXPR_OBJ_EXTEND1482			| EXPR_PARENED1483			| EXPR_INTRINSIC_THIS_FILE1484			| EXPR_INTRINSIC_ID1485			| EXPR_INTRINSIC1486			| EXPR_STRING1487			| EXPR_NUMBER1488			| EXPR_ARRAY1489			| EXPR_OBJECT1490			| EXPR_ARRAY_COMP1491			| EXPR_IMPORT1492			| EXPR_VAR1493			| EXPR_LOCAL1494			| EXPR_IF_THEN_ELSE1495			| EXPR_FUNCTION1496			| EXPR_ASSERT1497			| EXPR_ERROR => true,1498			_ => false,1499		}1500	}1501	fn cast(syntax: SyntaxNode) -> Option<Self> {1502		let res = match syntax.kind() {1503			EXPR_BINARY => Expr::ExprBinary(ExprBinary { syntax }),1504			EXPR_UNARY => Expr::ExprUnary(ExprUnary { syntax }),1505			EXPR_SLICE => Expr::ExprSlice(ExprSlice { syntax }),1506			EXPR_INDEX => Expr::ExprIndex(ExprIndex { syntax }),1507			EXPR_INDEX_EXPR => Expr::ExprIndexExpr(ExprIndexExpr { syntax }),1508			EXPR_APPLY => Expr::ExprApply(ExprApply { syntax }),1509			EXPR_OBJ_EXTEND => Expr::ExprObjExtend(ExprObjExtend { syntax }),1510			EXPR_PARENED => Expr::ExprParened(ExprParened { syntax }),1511			EXPR_INTRINSIC_THIS_FILE => {1512				Expr::ExprIntrinsicThisFile(ExprIntrinsicThisFile { syntax })1513			}1514			EXPR_INTRINSIC_ID => Expr::ExprIntrinsicId(ExprIntrinsicId { syntax }),1515			EXPR_INTRINSIC => Expr::ExprIntrinsic(ExprIntrinsic { syntax }),1516			EXPR_STRING => Expr::ExprString(ExprString { syntax }),1517			EXPR_NUMBER => Expr::ExprNumber(ExprNumber { syntax }),1518			EXPR_ARRAY => Expr::ExprArray(ExprArray { syntax }),1519			EXPR_OBJECT => Expr::ExprObject(ExprObject { syntax }),1520			EXPR_ARRAY_COMP => Expr::ExprArrayComp(ExprArrayComp { syntax }),1521			EXPR_IMPORT => Expr::ExprImport(ExprImport { syntax }),1522			EXPR_VAR => Expr::ExprVar(ExprVar { syntax }),1523			EXPR_LOCAL => Expr::ExprLocal(ExprLocal { syntax }),1524			EXPR_IF_THEN_ELSE => Expr::ExprIfThenElse(ExprIfThenElse { syntax }),1525			EXPR_FUNCTION => Expr::ExprFunction(ExprFunction { syntax }),1526			EXPR_ASSERT => Expr::ExprAssert(ExprAssert { syntax }),1527			EXPR_ERROR => Expr::ExprError(ExprError { syntax }),1528			_ => return None,1529		};1530		Some(res)1531	}1532	fn syntax(&self) -> &SyntaxNode {1533		match self {1534			Expr::ExprBinary(it) => &it.syntax,1535			Expr::ExprUnary(it) => &it.syntax,1536			Expr::ExprSlice(it) => &it.syntax,1537			Expr::ExprIndex(it) => &it.syntax,1538			Expr::ExprIndexExpr(it) => &it.syntax,1539			Expr::ExprApply(it) => &it.syntax,1540			Expr::ExprObjExtend(it) => &it.syntax,1541			Expr::ExprParened(it) => &it.syntax,1542			Expr::ExprIntrinsicThisFile(it) => &it.syntax,1543			Expr::ExprIntrinsicId(it) => &it.syntax,1544			Expr::ExprIntrinsic(it) => &it.syntax,1545			Expr::ExprString(it) => &it.syntax,1546			Expr::ExprNumber(it) => &it.syntax,1547			Expr::ExprArray(it) => &it.syntax,1548			Expr::ExprObject(it) => &it.syntax,1549			Expr::ExprArrayComp(it) => &it.syntax,1550			Expr::ExprImport(it) => &it.syntax,1551			Expr::ExprVar(it) => &it.syntax,1552			Expr::ExprLocal(it) => &it.syntax,1553			Expr::ExprIfThenElse(it) => &it.syntax,1554			Expr::ExprFunction(it) => &it.syntax,1555			Expr::ExprAssert(it) => &it.syntax,1556			Expr::ExprError(it) => &it.syntax,1557		}1558	}1559}1560impl From<ObjBodyComp> for ObjBody {1561	fn from(node: ObjBodyComp) -> ObjBody { ObjBody::ObjBodyComp(node) }1562}1563impl From<ObjBodyMemberList> for ObjBody {1564	fn from(node: ObjBodyMemberList) -> ObjBody { ObjBody::ObjBodyMemberList(node) }1565}1566impl AstNode for ObjBody {1567	fn can_cast(kind: SyntaxKind) -> bool {1568		match kind {1569			OBJ_BODY_COMP | OBJ_BODY_MEMBER_LIST => true,1570			_ => false,1571		}1572	}1573	fn cast(syntax: SyntaxNode) -> Option<Self> {1574		let res = match syntax.kind() {1575			OBJ_BODY_COMP => ObjBody::ObjBodyComp(ObjBodyComp { syntax }),1576			OBJ_BODY_MEMBER_LIST => ObjBody::ObjBodyMemberList(ObjBodyMemberList { syntax }),1577			_ => return None,1578		};1579		Some(res)1580	}1581	fn syntax(&self) -> &SyntaxNode {1582		match self {1583			ObjBody::ObjBodyComp(it) => &it.syntax,1584			ObjBody::ObjBodyMemberList(it) => &it.syntax,1585		}1586	}1587}1588impl From<ForSpec> for CompSpec {1589	fn from(node: ForSpec) -> CompSpec { CompSpec::ForSpec(node) }1590}1591impl From<IfSpec> for CompSpec {1592	fn from(node: IfSpec) -> CompSpec { CompSpec::IfSpec(node) }1593}1594impl AstNode for CompSpec {1595	fn can_cast(kind: SyntaxKind) -> bool {1596		match kind {1597			FOR_SPEC | IF_SPEC => true,1598			_ => false,1599		}1600	}1601	fn cast(syntax: SyntaxNode) -> Option<Self> {1602		let res = match syntax.kind() {1603			FOR_SPEC => CompSpec::ForSpec(ForSpec { syntax }),1604			IF_SPEC => CompSpec::IfSpec(IfSpec { syntax }),1605			_ => return None,1606		};1607		Some(res)1608	}1609	fn syntax(&self) -> &SyntaxNode {1610		match self {1611			CompSpec::ForSpec(it) => &it.syntax,1612			CompSpec::IfSpec(it) => &it.syntax,1613		}1614	}1615}1616impl From<BindDestruct> for Bind {1617	fn from(node: BindDestruct) -> Bind { Bind::BindDestruct(node) }1618}1619impl From<BindFunction> for Bind {1620	fn from(node: BindFunction) -> Bind { Bind::BindFunction(node) }1621}1622impl AstNode for Bind {1623	fn can_cast(kind: SyntaxKind) -> bool {1624		match kind {1625			BIND_DESTRUCT | BIND_FUNCTION => true,1626			_ => false,1627		}1628	}1629	fn cast(syntax: SyntaxNode) -> Option<Self> {1630		let res = match syntax.kind() {1631			BIND_DESTRUCT => Bind::BindDestruct(BindDestruct { syntax }),1632			BIND_FUNCTION => Bind::BindFunction(BindFunction { syntax }),1633			_ => return None,1634		};1635		Some(res)1636	}1637	fn syntax(&self) -> &SyntaxNode {1638		match self {1639			Bind::BindDestruct(it) => &it.syntax,1640			Bind::BindFunction(it) => &it.syntax,1641		}1642	}1643}1644impl From<MemberBindStmt> for Member {1645	fn from(node: MemberBindStmt) -> Member { Member::MemberBindStmt(node) }1646}1647impl From<MemberAssertStmt> for Member {1648	fn from(node: MemberAssertStmt) -> Member { Member::MemberAssertStmt(node) }1649}1650impl From<MemberField> for Member {1651	fn from(node: MemberField) -> Member { Member::MemberField(node) }1652}1653impl AstNode for Member {1654	fn can_cast(kind: SyntaxKind) -> bool {1655		match kind {1656			MEMBER_BIND_STMT | MEMBER_ASSERT_STMT | MEMBER_FIELD => true,1657			_ => false,1658		}1659	}1660	fn cast(syntax: SyntaxNode) -> Option<Self> {1661		let res = match syntax.kind() {1662			MEMBER_BIND_STMT => Member::MemberBindStmt(MemberBindStmt { syntax }),1663			MEMBER_ASSERT_STMT => Member::MemberAssertStmt(MemberAssertStmt { syntax }),1664			MEMBER_FIELD => Member::MemberField(MemberField { syntax }),1665			_ => return None,1666		};1667		Some(res)1668	}1669	fn syntax(&self) -> &SyntaxNode {1670		match self {1671			Member::MemberBindStmt(it) => &it.syntax,1672			Member::MemberAssertStmt(it) => &it.syntax,1673			Member::MemberField(it) => &it.syntax,1674		}1675	}1676}1677impl From<FieldNormal> for Field {1678	fn from(node: FieldNormal) -> Field { Field::FieldNormal(node) }1679}1680impl From<FieldMethod> for Field {1681	fn from(node: FieldMethod) -> Field { Field::FieldMethod(node) }1682}1683impl AstNode for Field {1684	fn can_cast(kind: SyntaxKind) -> bool {1685		match kind {1686			FIELD_NORMAL | FIELD_METHOD => true,1687			_ => false,1688		}1689	}1690	fn cast(syntax: SyntaxNode) -> Option<Self> {1691		let res = match syntax.kind() {1692			FIELD_NORMAL => Field::FieldNormal(FieldNormal { syntax }),1693			FIELD_METHOD => Field::FieldMethod(FieldMethod { syntax }),1694			_ => return None,1695		};1696		Some(res)1697	}1698	fn syntax(&self) -> &SyntaxNode {1699		match self {1700			Field::FieldNormal(it) => &it.syntax,1701			Field::FieldMethod(it) => &it.syntax,1702		}1703	}1704}1705impl From<FieldNameFixed> for FieldName {1706	fn from(node: FieldNameFixed) -> FieldName { FieldName::FieldNameFixed(node) }1707}1708impl From<FieldNameDynamic> for FieldName {1709	fn from(node: FieldNameDynamic) -> FieldName { FieldName::FieldNameDynamic(node) }1710}1711impl AstNode for FieldName {1712	fn can_cast(kind: SyntaxKind) -> bool {1713		match kind {1714			FIELD_NAME_FIXED | FIELD_NAME_DYNAMIC => true,1715			_ => false,1716		}1717	}1718	fn cast(syntax: SyntaxNode) -> Option<Self> {1719		let res = match syntax.kind() {1720			FIELD_NAME_FIXED => FieldName::FieldNameFixed(FieldNameFixed { syntax }),1721			FIELD_NAME_DYNAMIC => FieldName::FieldNameDynamic(FieldNameDynamic { syntax }),1722			_ => return None,1723		};1724		Some(res)1725	}1726	fn syntax(&self) -> &SyntaxNode {1727		match self {1728			FieldName::FieldNameFixed(it) => &it.syntax,1729			FieldName::FieldNameDynamic(it) => &it.syntax,1730		}1731	}1732}1733impl std::fmt::Display for Expr {1734	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {1735		std::fmt::Display::fmt(self.syntax(), f)1736	}1737}1738impl std::fmt::Display for ObjBody {1739	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {1740		std::fmt::Display::fmt(self.syntax(), f)1741	}1742}1743impl std::fmt::Display for CompSpec {1744	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {1745		std::fmt::Display::fmt(self.syntax(), f)1746	}1747}1748impl std::fmt::Display for Bind {1749	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {1750		std::fmt::Display::fmt(self.syntax(), f)1751	}1752}1753impl std::fmt::Display for Member {1754	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {1755		std::fmt::Display::fmt(self.syntax(), f)1756	}1757}1758impl std::fmt::Display for Field {1759	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {1760		std::fmt::Display::fmt(self.syntax(), f)1761	}1762}1763impl std::fmt::Display for FieldName {1764	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {1765		std::fmt::Display::fmt(self.syntax(), f)1766	}1767}1768impl std::fmt::Display for SourceFile {1769	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {1770		std::fmt::Display::fmt(self.syntax(), f)1771	}1772}1773impl std::fmt::Display for ExprBinary {1774	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {1775		std::fmt::Display::fmt(self.syntax(), f)1776	}1777}1778impl std::fmt::Display for BinaryOperator {1779	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {1780		std::fmt::Display::fmt(self.syntax(), f)1781	}1782}1783impl std::fmt::Display for ExprUnary {1784	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {1785		std::fmt::Display::fmt(self.syntax(), f)1786	}1787}1788impl std::fmt::Display for UnaryOperator {1789	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {1790		std::fmt::Display::fmt(self.syntax(), f)1791	}1792}1793impl std::fmt::Display for ExprSlice {1794	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {1795		std::fmt::Display::fmt(self.syntax(), f)1796	}1797}1798impl std::fmt::Display for SliceDesc {1799	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {1800		std::fmt::Display::fmt(self.syntax(), f)1801	}1802}1803impl std::fmt::Display for ExprIndex {1804	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {1805		std::fmt::Display::fmt(self.syntax(), f)1806	}1807}1808impl std::fmt::Display for Name {1809	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {1810		std::fmt::Display::fmt(self.syntax(), f)1811	}1812}1813impl std::fmt::Display for ExprIndexExpr {1814	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {1815		std::fmt::Display::fmt(self.syntax(), f)1816	}1817}1818impl std::fmt::Display for ExprApply {1819	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {1820		std::fmt::Display::fmt(self.syntax(), f)1821	}1822}1823impl std::fmt::Display for ArgsDesc {1824	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {1825		std::fmt::Display::fmt(self.syntax(), f)1826	}1827}1828impl std::fmt::Display for ExprObjExtend {1829	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {1830		std::fmt::Display::fmt(self.syntax(), f)1831	}1832}1833impl std::fmt::Display for ExprParened {1834	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {1835		std::fmt::Display::fmt(self.syntax(), f)1836	}1837}1838impl std::fmt::Display for ExprLiteral {1839	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {1840		std::fmt::Display::fmt(self.syntax(), f)1841	}1842}1843impl std::fmt::Display for Literal {1844	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {1845		std::fmt::Display::fmt(self.syntax(), f)1846	}1847}1848impl std::fmt::Display for ExprIntrinsicThisFile {1849	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {1850		std::fmt::Display::fmt(self.syntax(), f)1851	}1852}1853impl std::fmt::Display for ExprIntrinsicId {1854	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {1855		std::fmt::Display::fmt(self.syntax(), f)1856	}1857}1858impl std::fmt::Display for ExprIntrinsic {1859	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {1860		std::fmt::Display::fmt(self.syntax(), f)1861	}1862}1863impl std::fmt::Display for ExprString {1864	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {1865		std::fmt::Display::fmt(self.syntax(), f)1866	}1867}1868impl std::fmt::Display for String {1869	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {1870		std::fmt::Display::fmt(self.syntax(), f)1871	}1872}1873impl std::fmt::Display for ExprNumber {1874	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {1875		std::fmt::Display::fmt(self.syntax(), f)1876	}1877}1878impl std::fmt::Display for Number {1879	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {1880		std::fmt::Display::fmt(self.syntax(), f)1881	}1882}1883impl std::fmt::Display for ExprArray {1884	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {1885		std::fmt::Display::fmt(self.syntax(), f)1886	}1887}1888impl std::fmt::Display for ExprObject {1889	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {1890		std::fmt::Display::fmt(self.syntax(), f)1891	}1892}1893impl std::fmt::Display for ExprArrayComp {1894	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {1895		std::fmt::Display::fmt(self.syntax(), f)1896	}1897}1898impl std::fmt::Display for ForSpec {1899	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {1900		std::fmt::Display::fmt(self.syntax(), f)1901	}1902}1903impl std::fmt::Display for ExprImport {1904	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {1905		std::fmt::Display::fmt(self.syntax(), f)1906	}1907}1908impl std::fmt::Display for ExprVar {1909	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {1910		std::fmt::Display::fmt(self.syntax(), f)1911	}1912}1913impl std::fmt::Display for ExprLocal {1914	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {1915		std::fmt::Display::fmt(self.syntax(), f)1916	}1917}1918impl std::fmt::Display for ExprIfThenElse {1919	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {1920		std::fmt::Display::fmt(self.syntax(), f)1921	}1922}1923impl std::fmt::Display for ExprFunction {1924	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {1925		std::fmt::Display::fmt(self.syntax(), f)1926	}1927}1928impl std::fmt::Display for ParamsDesc {1929	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {1930		std::fmt::Display::fmt(self.syntax(), f)1931	}1932}1933impl std::fmt::Display for ExprAssert {1934	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {1935		std::fmt::Display::fmt(self.syntax(), f)1936	}1937}1938impl std::fmt::Display for Assertion {1939	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {1940		std::fmt::Display::fmt(self.syntax(), f)1941	}1942}1943impl std::fmt::Display for ExprError {1944	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {1945		std::fmt::Display::fmt(self.syntax(), f)1946	}1947}1948impl std::fmt::Display for Arg {1949	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {1950		std::fmt::Display::fmt(self.syntax(), f)1951	}1952}1953impl std::fmt::Display for ObjBodyComp {1954	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {1955		std::fmt::Display::fmt(self.syntax(), f)1956	}1957}1958impl std::fmt::Display for ObjLocalPostComma {1959	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {1960		std::fmt::Display::fmt(self.syntax(), f)1961	}1962}1963impl std::fmt::Display for ObjLocalPreComma {1964	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {1965		std::fmt::Display::fmt(self.syntax(), f)1966	}1967}1968impl std::fmt::Display for ObjBodyMemberList {1969	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {1970		std::fmt::Display::fmt(self.syntax(), f)1971	}1972}1973impl std::fmt::Display for ObjLocal {1974	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {1975		std::fmt::Display::fmt(self.syntax(), f)1976	}1977}1978impl std::fmt::Display for MemberBindStmt {1979	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {1980		std::fmt::Display::fmt(self.syntax(), f)1981	}1982}1983impl std::fmt::Display for MemberAssertStmt {1984	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {1985		std::fmt::Display::fmt(self.syntax(), f)1986	}1987}1988impl std::fmt::Display for MemberField {1989	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {1990		std::fmt::Display::fmt(self.syntax(), f)1991	}1992}1993impl std::fmt::Display for FieldNormal {1994	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {1995		std::fmt::Display::fmt(self.syntax(), f)1996	}1997}1998impl std::fmt::Display for Visibility {1999	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2000		std::fmt::Display::fmt(self.syntax(), f)2001	}2002}2003impl std::fmt::Display for FieldMethod {2004	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2005		std::fmt::Display::fmt(self.syntax(), f)2006	}2007}2008impl std::fmt::Display for FieldNameFixed {2009	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2010		std::fmt::Display::fmt(self.syntax(), f)2011	}2012}2013impl std::fmt::Display for FieldNameDynamic {2014	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2015		std::fmt::Display::fmt(self.syntax(), f)2016	}2017}2018impl std::fmt::Display for IfSpec {2019	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2020		std::fmt::Display::fmt(self.syntax(), f)2021	}2022}2023impl std::fmt::Display for BindDestruct {2024	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2025		std::fmt::Display::fmt(self.syntax(), f)2026	}2027}2028impl std::fmt::Display for Destruct {2029	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2030		std::fmt::Display::fmt(self.syntax(), f)2031	}2032}2033impl std::fmt::Display for BindFunction {2034	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2035		std::fmt::Display::fmt(self.syntax(), f)2036	}2037}2038impl std::fmt::Display for Param {2039	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2040		std::fmt::Display::fmt(self.syntax(), f)2041	}2042}2043impl std::fmt::Display for DestructFull {2044	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2045		std::fmt::Display::fmt(self.syntax(), f)2046	}2047}2048impl std::fmt::Display for DestructSkip {2049	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2050		std::fmt::Display::fmt(self.syntax(), f)2051	}2052}2053impl std::fmt::Display for DestructArray {2054	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2055		std::fmt::Display::fmt(self.syntax(), f)2056	}2057}2058impl std::fmt::Display for DestructRest {2059	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2060		std::fmt::Display::fmt(self.syntax(), f)2061	}2062}2063impl std::fmt::Display for DestructObject {2064	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2065		std::fmt::Display::fmt(self.syntax(), f)2066	}2067}2068impl std::fmt::Display for DestructObjectField {2069	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2070		std::fmt::Display::fmt(self.syntax(), f)2071	}2072}