1234#![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}