1234#![allow(non_snake_case, clippy::match_like_matches_macro)]5use crate::{6 ast::{support, AstChildren, AstNode, AstToken},7 SyntaxKind::{self, *},8 SyntaxNode, SyntaxToken, T,9};1011#[derive(Debug, Clone, PartialEq, Eq, Hash)]12pub struct SourceFile {13 pub(crate) syntax: SyntaxNode,14}15impl SourceFile {16 pub fn expr(&self) -> Option<Expr> {17 support::child(&self.syntax)18 }19}2021#[derive(Debug, Clone, PartialEq, Eq, Hash)]22pub struct ExprBinary {23 pub(crate) syntax: SyntaxNode,24}25impl ExprBinary {26 pub fn lhs(&self) -> Option<LhsExpr> {27 support::child(&self.syntax)28 }29 pub fn binary_operator(&self) -> Option<BinaryOperator> {30 support::token_child(&self.syntax)31 }32 pub fn rhs(&self) -> Option<Expr> {33 support::child(&self.syntax)34 }35}3637#[derive(Debug, Clone, PartialEq, Eq, Hash)]38pub struct LhsExpr {39 pub(crate) syntax: SyntaxNode,40}41impl LhsExpr {42 pub fn expr(&self) -> Option<Expr> {43 support::child(&self.syntax)44 }45}4647#[derive(Debug, Clone, PartialEq, Eq, Hash)]48pub struct ExprUnary {49 pub(crate) syntax: SyntaxNode,50}51impl ExprUnary {52 pub fn unary_operator(&self) -> Option<UnaryOperator> {53 support::token_child(&self.syntax)54 }55 pub fn rhs(&self) -> Option<Expr> {56 support::child(&self.syntax)57 }58}5960#[derive(Debug, Clone, PartialEq, Eq, Hash)]61pub struct ExprSlice {62 pub(crate) syntax: SyntaxNode,63}64impl ExprSlice {65 pub fn expr(&self) -> Option<Expr> {66 support::child(&self.syntax)67 }68 pub fn slice_desc(&self) -> Option<SliceDesc> {69 support::child(&self.syntax)70 }71}7273#[derive(Debug, Clone, PartialEq, Eq, Hash)]74pub struct SliceDesc {75 pub(crate) syntax: SyntaxNode,76}77impl SliceDesc {78 pub fn l_brack_token(&self) -> Option<SyntaxToken> {79 support::token(&self.syntax, T!['['])80 }81 pub fn from(&self) -> Option<Expr> {82 support::child(&self.syntax)83 }84 pub fn colon_token(&self) -> Option<SyntaxToken> {85 support::token(&self.syntax, T![:])86 }87 pub fn end(&self) -> Option<SliceDescEnd> {88 support::child(&self.syntax)89 }90 pub fn step(&self) -> Option<SliceDescStep> {91 support::child(&self.syntax)92 }93 pub fn r_brack_token(&self) -> Option<SyntaxToken> {94 support::token(&self.syntax, T![']'])95 }96}9798#[derive(Debug, Clone, PartialEq, Eq, Hash)]99pub struct ExprIndex {100 pub(crate) syntax: SyntaxNode,101}102impl ExprIndex {103 pub fn expr(&self) -> Option<Expr> {104 support::child(&self.syntax)105 }106 pub fn dot_token(&self) -> Option<SyntaxToken> {107 support::token(&self.syntax, T![.])108 }109 pub fn index(&self) -> Option<Name> {110 support::child(&self.syntax)111 }112}113114#[derive(Debug, Clone, PartialEq, Eq, Hash)]115pub struct Name {116 pub(crate) syntax: SyntaxNode,117}118impl Name {119 pub fn ident_lit(&self) -> Option<SyntaxToken> {120 support::token(&self.syntax, IDENT)121 }122}123124#[derive(Debug, Clone, PartialEq, Eq, Hash)]125pub struct ExprIndexExpr {126 pub(crate) syntax: SyntaxNode,127}128impl ExprIndexExpr {129 pub fn base(&self) -> Option<LhsExpr> {130 support::child(&self.syntax)131 }132 pub fn l_brack_token(&self) -> Option<SyntaxToken> {133 support::token(&self.syntax, T!['['])134 }135 pub fn index(&self) -> Option<Expr> {136 support::child(&self.syntax)137 }138 pub fn r_brack_token(&self) -> Option<SyntaxToken> {139 support::token(&self.syntax, T![']'])140 }141}142143#[derive(Debug, Clone, PartialEq, Eq, Hash)]144pub struct ExprApply {145 pub(crate) syntax: SyntaxNode,146}147impl ExprApply {148 pub fn expr(&self) -> Option<Expr> {149 support::child(&self.syntax)150 }151 pub fn args_desc(&self) -> Option<ArgsDesc> {152 support::child(&self.syntax)153 }154 pub fn tailstrict_kw_token(&self) -> Option<SyntaxToken> {155 support::token(&self.syntax, T![tailstrict])156 }157}158159#[derive(Debug, Clone, PartialEq, Eq, Hash)]160pub struct ArgsDesc {161 pub(crate) syntax: SyntaxNode,162}163impl ArgsDesc {164 pub fn l_paren_token(&self) -> Option<SyntaxToken> {165 support::token(&self.syntax, T!['('])166 }167 pub fn args(&self) -> AstChildren<Arg> {168 support::children(&self.syntax)169 }170 pub fn r_paren_token(&self) -> Option<SyntaxToken> {171 support::token(&self.syntax, T![')'])172 }173}174175#[derive(Debug, Clone, PartialEq, Eq, Hash)]176pub struct ExprObjExtend {177 pub(crate) syntax: SyntaxNode,178}179impl ExprObjExtend {180 pub fn lhs_expr(&self) -> Option<LhsExpr> {181 support::child(&self.syntax)182 }183 pub fn expr(&self) -> Option<Expr> {184 support::child(&self.syntax)185 }186}187188#[derive(Debug, Clone, PartialEq, Eq, Hash)]189pub struct ExprParened {190 pub(crate) syntax: SyntaxNode,191}192impl ExprParened {193 pub fn l_paren_token(&self) -> Option<SyntaxToken> {194 support::token(&self.syntax, T!['('])195 }196 pub fn expr(&self) -> Option<Expr> {197 support::child(&self.syntax)198 }199 pub fn r_paren_token(&self) -> Option<SyntaxToken> {200 support::token(&self.syntax, T![')'])201 }202}203204#[derive(Debug, Clone, PartialEq, Eq, Hash)]205pub struct ExprLiteral {206 pub(crate) syntax: SyntaxNode,207}208impl ExprLiteral {209 pub fn literal(&self) -> Option<Literal> {210 support::token_child(&self.syntax)211 }212}213214#[derive(Debug, Clone, PartialEq, Eq, Hash)]215pub struct ExprIntrinsicThisFile {216 pub(crate) syntax: SyntaxNode,217}218impl ExprIntrinsicThisFile {219 pub fn intrinsic_this_file_token(&self) -> Option<SyntaxToken> {220 support::token(&self.syntax, T!["$intrinsicThisFile"])221 }222}223224#[derive(Debug, Clone, PartialEq, Eq, Hash)]225pub struct ExprIntrinsicId {226 pub(crate) syntax: SyntaxNode,227}228impl ExprIntrinsicId {229 pub fn intrinsic_id_token(&self) -> Option<SyntaxToken> {230 support::token(&self.syntax, T!["$intrinsicId"])231 }232}233234#[derive(Debug, Clone, PartialEq, Eq, Hash)]235pub struct ExprIntrinsic {236 pub(crate) syntax: SyntaxNode,237}238impl ExprIntrinsic {239 pub fn intrinsic_token(&self) -> Option<SyntaxToken> {240 support::token(&self.syntax, T!["$intrinsic"])241 }242 pub fn l_paren_token(&self) -> Option<SyntaxToken> {243 support::token(&self.syntax, T!['('])244 }245 pub fn name(&self) -> Option<Name> {246 support::child(&self.syntax)247 }248 pub fn r_paren_token(&self) -> Option<SyntaxToken> {249 support::token(&self.syntax, T![')'])250 }251}252253#[derive(Debug, Clone, PartialEq, Eq, Hash)]254pub struct ExprString {255 pub(crate) syntax: SyntaxNode,256}257impl ExprString {258 pub fn text(&self) -> Option<Text> {259 support::token_child(&self.syntax)260 }261}262263#[derive(Debug, Clone, PartialEq, Eq, Hash)]264pub struct ExprNumber {265 pub(crate) syntax: SyntaxNode,266}267impl ExprNumber {268 pub fn number(&self) -> Option<Number> {269 support::token_child(&self.syntax)270 }271}272273#[derive(Debug, Clone, PartialEq, Eq, Hash)]274pub struct ExprArray {275 pub(crate) syntax: SyntaxNode,276}277impl ExprArray {278 pub fn l_brack_token(&self) -> Option<SyntaxToken> {279 support::token(&self.syntax, T!['['])280 }281 pub fn exprs(&self) -> AstChildren<Expr> {282 support::children(&self.syntax)283 }284 pub fn r_brack_token(&self) -> Option<SyntaxToken> {285 support::token(&self.syntax, T![']'])286 }287}288289#[derive(Debug, Clone, PartialEq, Eq, Hash)]290pub struct ExprObject {291 pub(crate) syntax: SyntaxNode,292}293impl ExprObject {294 pub fn obj_body(&self) -> Option<ObjBody> {295 support::child(&self.syntax)296 }297}298299#[derive(Debug, Clone, PartialEq, Eq, Hash)]300pub struct ExprArrayComp {301 pub(crate) syntax: SyntaxNode,302}303impl ExprArrayComp {304 pub fn l_brack_token(&self) -> Option<SyntaxToken> {305 support::token(&self.syntax, T!['['])306 }307 pub fn expr(&self) -> Option<Expr> {308 support::child(&self.syntax)309 }310 pub fn comma_token(&self) -> Option<SyntaxToken> {311 support::token(&self.syntax, T![,])312 }313 pub fn comp_specs(&self) -> AstChildren<CompSpec> {314 support::children(&self.syntax)315 }316 pub fn r_brack_token(&self) -> Option<SyntaxToken> {317 support::token(&self.syntax, T![']'])318 }319}320321#[derive(Debug, Clone, PartialEq, Eq, Hash)]322pub struct ExprImport {323 pub(crate) syntax: SyntaxNode,324}325impl ExprImport {326 pub fn import_kind(&self) -> Option<ImportKind> {327 support::token_child(&self.syntax)328 }329 pub fn text(&self) -> Option<Text> {330 support::token_child(&self.syntax)331 }332}333334#[derive(Debug, Clone, PartialEq, Eq, Hash)]335pub struct ExprVar {336 pub(crate) syntax: SyntaxNode,337}338impl ExprVar {339 pub fn name(&self) -> Option<Name> {340 support::child(&self.syntax)341 }342}343344#[derive(Debug, Clone, PartialEq, Eq, Hash)]345pub struct ExprLocal {346 pub(crate) syntax: SyntaxNode,347}348impl ExprLocal {349 pub fn local_kw_token(&self) -> Option<SyntaxToken> {350 support::token(&self.syntax, T![local])351 }352 pub fn binds(&self) -> AstChildren<Bind> {353 support::children(&self.syntax)354 }355 pub fn semi_token(&self) -> Option<SyntaxToken> {356 support::token(&self.syntax, T![;])357 }358 pub fn expr(&self) -> Option<Expr> {359 support::child(&self.syntax)360 }361}362363#[derive(Debug, Clone, PartialEq, Eq, Hash)]364pub struct ExprIfThenElse {365 pub(crate) syntax: SyntaxNode,366}367impl ExprIfThenElse {368 pub fn if_kw_token(&self) -> Option<SyntaxToken> {369 support::token(&self.syntax, T![if])370 }371 pub fn cond(&self) -> Option<Expr> {372 support::child(&self.syntax)373 }374 pub fn then_kw_token(&self) -> Option<SyntaxToken> {375 support::token(&self.syntax, T![then])376 }377 pub fn then(&self) -> Option<TrueExpr> {378 support::child(&self.syntax)379 }380 pub fn else_kw_token(&self) -> Option<SyntaxToken> {381 support::token(&self.syntax, T![else])382 }383 pub fn else_(&self) -> Option<FalseExpr> {384 support::child(&self.syntax)385 }386}387388#[derive(Debug, Clone, PartialEq, Eq, Hash)]389pub struct TrueExpr {390 pub(crate) syntax: SyntaxNode,391}392impl TrueExpr {393 pub fn expr(&self) -> Option<Expr> {394 support::child(&self.syntax)395 }396}397398#[derive(Debug, Clone, PartialEq, Eq, Hash)]399pub struct FalseExpr {400 pub(crate) syntax: SyntaxNode,401}402impl FalseExpr {403 pub fn expr(&self) -> Option<Expr> {404 support::child(&self.syntax)405 }406}407408#[derive(Debug, Clone, PartialEq, Eq, Hash)]409pub struct ExprFunction {410 pub(crate) syntax: SyntaxNode,411}412impl ExprFunction {413 pub fn function_kw_token(&self) -> Option<SyntaxToken> {414 support::token(&self.syntax, T![function])415 }416 pub fn l_paren_token(&self) -> Option<SyntaxToken> {417 support::token(&self.syntax, T!['('])418 }419 pub fn params_desc(&self) -> Option<ParamsDesc> {420 support::child(&self.syntax)421 }422 pub fn r_paren_token(&self) -> Option<SyntaxToken> {423 support::token(&self.syntax, T![')'])424 }425 pub fn expr(&self) -> Option<Expr> {426 support::child(&self.syntax)427 }428}429430#[derive(Debug, Clone, PartialEq, Eq, Hash)]431pub struct ParamsDesc {432 pub(crate) syntax: SyntaxNode,433}434impl ParamsDesc {435 pub fn l_paren_token(&self) -> Option<SyntaxToken> {436 support::token(&self.syntax, T!['('])437 }438 pub fn params(&self) -> AstChildren<Param> {439 support::children(&self.syntax)440 }441 pub fn r_paren_token(&self) -> Option<SyntaxToken> {442 support::token(&self.syntax, T![')'])443 }444}445446#[derive(Debug, Clone, PartialEq, Eq, Hash)]447pub struct ExprAssert {448 pub(crate) syntax: SyntaxNode,449}450impl ExprAssert {451 pub fn assertion(&self) -> Option<Assertion> {452 support::child(&self.syntax)453 }454 pub fn semi_token(&self) -> Option<SyntaxToken> {455 support::token(&self.syntax, T![;])456 }457 pub fn expr(&self) -> Option<Expr> {458 support::child(&self.syntax)459 }460}461462#[derive(Debug, Clone, PartialEq, Eq, Hash)]463pub struct Assertion {464 pub(crate) syntax: SyntaxNode,465}466impl Assertion {467 pub fn assert_kw_token(&self) -> Option<SyntaxToken> {468 support::token(&self.syntax, T![assert])469 }470 pub fn condition(&self) -> Option<LhsExpr> {471 support::child(&self.syntax)472 }473 pub fn colon_token(&self) -> Option<SyntaxToken> {474 support::token(&self.syntax, T![:])475 }476 pub fn message(&self) -> Option<Expr> {477 support::child(&self.syntax)478 }479}480481#[derive(Debug, Clone, PartialEq, Eq, Hash)]482pub struct ExprError {483 pub(crate) syntax: SyntaxNode,484}485impl ExprError {486 pub fn error_kw_token(&self) -> Option<SyntaxToken> {487 support::token(&self.syntax, T![error])488 }489 pub fn expr(&self) -> Option<Expr> {490 support::child(&self.syntax)491 }492}493494#[derive(Debug, Clone, PartialEq, Eq, Hash)]495pub struct SliceDescEnd {496 pub(crate) syntax: SyntaxNode,497}498impl SliceDescEnd {499 pub fn expr(&self) -> Option<Expr> {500 support::child(&self.syntax)501 }502}503504#[derive(Debug, Clone, PartialEq, Eq, Hash)]505pub struct SliceDescStep {506 pub(crate) syntax: SyntaxNode,507}508impl SliceDescStep {509 pub fn expr(&self) -> Option<Expr> {510 support::child(&self.syntax)511 }512}513514#[derive(Debug, Clone, PartialEq, Eq, Hash)]515pub struct Arg {516 pub(crate) syntax: SyntaxNode,517}518impl Arg {519 pub fn name(&self) -> Option<Name> {520 support::child(&self.syntax)521 }522 pub fn assign_token(&self) -> Option<SyntaxToken> {523 support::token(&self.syntax, T![=])524 }525 pub fn expr(&self) -> Option<Expr> {526 support::child(&self.syntax)527 }528}529530#[derive(Debug, Clone, PartialEq, Eq, Hash)]531pub struct ObjBodyComp {532 pub(crate) syntax: SyntaxNode,533}534impl ObjBodyComp {535 pub fn l_brace_token(&self) -> Option<SyntaxToken> {536 support::token(&self.syntax, T!['{'])537 }538 pub fn pre(&self) -> AstChildren<ObjLocalPostComma> {539 support::children(&self.syntax)540 }541 pub fn l_brack_token(&self) -> Option<SyntaxToken> {542 support::token(&self.syntax, T!['['])543 }544 pub fn key(&self) -> Option<LhsExpr> {545 support::child(&self.syntax)546 }547 pub fn r_brack_token(&self) -> Option<SyntaxToken> {548 support::token(&self.syntax, T![']'])549 }550 pub fn plus_token(&self) -> Option<SyntaxToken> {551 support::token(&self.syntax, T![+])552 }553 pub fn colon_token(&self) -> Option<SyntaxToken> {554 support::token(&self.syntax, T![:])555 }556 pub fn value(&self) -> Option<Expr> {557 support::child(&self.syntax)558 }559 pub fn post(&self) -> AstChildren<ObjLocalPreComma> {560 support::children(&self.syntax)561 }562 pub fn comp_specs(&self) -> AstChildren<CompSpec> {563 support::children(&self.syntax)564 }565 pub fn r_brace_token(&self) -> Option<SyntaxToken> {566 support::token(&self.syntax, T!['}'])567 }568}569570#[derive(Debug, Clone, PartialEq, Eq, Hash)]571pub struct ObjLocalPostComma {572 pub(crate) syntax: SyntaxNode,573}574impl ObjLocalPostComma {575 pub fn obj_local(&self) -> Option<ObjLocal> {576 support::child(&self.syntax)577 }578 pub fn comma_token(&self) -> Option<SyntaxToken> {579 support::token(&self.syntax, T![,])580 }581}582583#[derive(Debug, Clone, PartialEq, Eq, Hash)]584pub struct ObjLocalPreComma {585 pub(crate) syntax: SyntaxNode,586}587impl ObjLocalPreComma {588 pub fn comma_token(&self) -> Option<SyntaxToken> {589 support::token(&self.syntax, T![,])590 }591 pub fn obj_local(&self) -> Option<ObjLocal> {592 support::child(&self.syntax)593 }594}595596#[derive(Debug, Clone, PartialEq, Eq, Hash)]597pub struct ObjBodyMemberList {598 pub(crate) syntax: SyntaxNode,599}600impl ObjBodyMemberList {601 pub fn l_brace_token(&self) -> Option<SyntaxToken> {602 support::token(&self.syntax, T!['{'])603 }604 pub fn members(&self) -> AstChildren<Member> {605 support::children(&self.syntax)606 }607 pub fn r_brace_token(&self) -> Option<SyntaxToken> {608 support::token(&self.syntax, T!['}'])609 }610}611612#[derive(Debug, Clone, PartialEq, Eq, Hash)]613pub struct ObjLocal {614 pub(crate) syntax: SyntaxNode,615}616impl ObjLocal {617 pub fn local_kw_token(&self) -> Option<SyntaxToken> {618 support::token(&self.syntax, T![local])619 }620 pub fn bind(&self) -> Option<Bind> {621 support::child(&self.syntax)622 }623}624625#[derive(Debug, Clone, PartialEq, Eq, Hash)]626pub struct MemberBindStmt {627 pub(crate) syntax: SyntaxNode,628}629impl MemberBindStmt {630 pub fn obj_local(&self) -> Option<ObjLocal> {631 support::child(&self.syntax)632 }633}634635#[derive(Debug, Clone, PartialEq, Eq, Hash)]636pub struct MemberAssertStmt {637 pub(crate) syntax: SyntaxNode,638}639impl MemberAssertStmt {640 pub fn assertion(&self) -> Option<Assertion> {641 support::child(&self.syntax)642 }643}644645#[derive(Debug, Clone, PartialEq, Eq, Hash)]646pub struct MemberField {647 pub(crate) syntax: SyntaxNode,648}649impl MemberField {650 pub fn field(&self) -> Option<Field> {651 support::child(&self.syntax)652 }653}654655#[derive(Debug, Clone, PartialEq, Eq, Hash)]656pub struct FieldNormal {657 pub(crate) syntax: SyntaxNode,658}659impl FieldNormal {660 pub fn field_name(&self) -> Option<FieldName> {661 support::child(&self.syntax)662 }663 pub fn plus_token(&self) -> Option<SyntaxToken> {664 support::token(&self.syntax, T![+])665 }666 pub fn visibility(&self) -> Option<Visibility> {667 support::token_child(&self.syntax)668 }669 pub fn expr(&self) -> Option<Expr> {670 support::child(&self.syntax)671 }672}673674#[derive(Debug, Clone, PartialEq, Eq, Hash)]675pub struct FieldMethod {676 pub(crate) syntax: SyntaxNode,677}678impl FieldMethod {679 pub fn field_name(&self) -> Option<FieldName> {680 support::child(&self.syntax)681 }682 pub fn params_desc(&self) -> Option<ParamsDesc> {683 support::child(&self.syntax)684 }685 pub fn visibility(&self) -> Option<Visibility> {686 support::token_child(&self.syntax)687 }688 pub fn expr(&self) -> Option<Expr> {689 support::child(&self.syntax)690 }691}692693#[derive(Debug, Clone, PartialEq, Eq, Hash)]694pub struct FieldNameFixed {695 pub(crate) syntax: SyntaxNode,696}697impl FieldNameFixed {698 pub fn id(&self) -> Option<Name> {699 support::child(&self.syntax)700 }701 pub fn text(&self) -> Option<Text> {702 support::token_child(&self.syntax)703 }704}705706#[derive(Debug, Clone, PartialEq, Eq, Hash)]707pub struct FieldNameDynamic {708 pub(crate) syntax: SyntaxNode,709}710impl FieldNameDynamic {711 pub fn l_brack_token(&self) -> Option<SyntaxToken> {712 support::token(&self.syntax, T!['['])713 }714 pub fn expr(&self) -> Option<Expr> {715 support::child(&self.syntax)716 }717 pub fn r_brack_token(&self) -> Option<SyntaxToken> {718 support::token(&self.syntax, T![']'])719 }720}721722#[derive(Debug, Clone, PartialEq, Eq, Hash)]723pub struct ForSpec {724 pub(crate) syntax: SyntaxNode,725}726impl ForSpec {727 pub fn for_kw_token(&self) -> Option<SyntaxToken> {728 support::token(&self.syntax, T![for])729 }730 pub fn bind(&self) -> Option<Name> {731 support::child(&self.syntax)732 }733 pub fn in_kw_token(&self) -> Option<SyntaxToken> {734 support::token(&self.syntax, T![in])735 }736 pub fn expr(&self) -> Option<Expr> {737 support::child(&self.syntax)738 }739}740741#[derive(Debug, Clone, PartialEq, Eq, Hash)]742pub struct IfSpec {743 pub(crate) syntax: SyntaxNode,744}745impl IfSpec {746 pub fn if_kw_token(&self) -> Option<SyntaxToken> {747 support::token(&self.syntax, T![if])748 }749 pub fn expr(&self) -> Option<Expr> {750 support::child(&self.syntax)751 }752}753754#[derive(Debug, Clone, PartialEq, Eq, Hash)]755pub struct BindDestruct {756 pub(crate) syntax: SyntaxNode,757}758impl BindDestruct {759 pub fn into(&self) -> Option<Destruct> {760 support::child(&self.syntax)761 }762 pub fn assign_token(&self) -> Option<SyntaxToken> {763 support::token(&self.syntax, T![=])764 }765 pub fn value(&self) -> Option<Expr> {766 support::child(&self.syntax)767 }768}769770#[derive(Debug, Clone, PartialEq, Eq, Hash)]771pub struct BindFunction {772 pub(crate) syntax: SyntaxNode,773}774impl BindFunction {775 pub fn name(&self) -> Option<Name> {776 support::child(&self.syntax)777 }778 pub fn params(&self) -> Option<ParamsDesc> {779 support::child(&self.syntax)780 }781 pub fn assign_token(&self) -> Option<SyntaxToken> {782 support::token(&self.syntax, T![=])783 }784 pub fn value(&self) -> Option<Expr> {785 support::child(&self.syntax)786 }787}788789#[derive(Debug, Clone, PartialEq, Eq, Hash)]790pub struct Param {791 pub(crate) syntax: SyntaxNode,792}793impl Param {794 pub fn destruct(&self) -> Option<Destruct> {795 support::child(&self.syntax)796 }797 pub fn assign_token(&self) -> Option<SyntaxToken> {798 support::token(&self.syntax, T![=])799 }800 pub fn expr(&self) -> Option<Expr> {801 support::child(&self.syntax)802 }803}804805#[derive(Debug, Clone, PartialEq, Eq, Hash)]806pub struct DestructFull {807 pub(crate) syntax: SyntaxNode,808}809impl DestructFull {810 pub fn name(&self) -> Option<Name> {811 support::child(&self.syntax)812 }813}814815#[derive(Debug, Clone, PartialEq, Eq, Hash)]816pub struct DestructSkip {817 pub(crate) syntax: SyntaxNode,818}819impl DestructSkip {820 pub fn question_mark_token(&self) -> Option<SyntaxToken> {821 support::token(&self.syntax, T![?])822 }823}824825#[derive(Debug, Clone, PartialEq, Eq, Hash)]826pub struct DestructArray {827 pub(crate) syntax: SyntaxNode,828}829impl DestructArray {830 pub fn l_brack_token(&self) -> Option<SyntaxToken> {831 support::token(&self.syntax, T!['['])832 }833 pub fn destruct_array_parts(&self) -> AstChildren<DestructArrayPart> {834 support::children(&self.syntax)835 }836 pub fn r_brack_token(&self) -> Option<SyntaxToken> {837 support::token(&self.syntax, T![']'])838 }839}840841#[derive(Debug, Clone, PartialEq, Eq, Hash)]842pub struct DestructObject {843 pub(crate) syntax: SyntaxNode,844}845impl DestructObject {846 pub fn l_brace_token(&self) -> Option<SyntaxToken> {847 support::token(&self.syntax, T!['{'])848 }849 pub fn destruct_object_fields(&self) -> AstChildren<DestructObjectField> {850 support::children(&self.syntax)851 }852 pub fn destruct_rest(&self) -> Option<DestructRest> {853 support::child(&self.syntax)854 }855 pub fn comma_token(&self) -> Option<SyntaxToken> {856 support::token(&self.syntax, T![,])857 }858 pub fn r_brace_token(&self) -> Option<SyntaxToken> {859 support::token(&self.syntax, T!['}'])860 }861}862863#[derive(Debug, Clone, PartialEq, Eq, Hash)]864pub struct DestructObjectField {865 pub(crate) syntax: SyntaxNode,866}867impl DestructObjectField {868 pub fn field(&self) -> Option<Name> {869 support::child(&self.syntax)870 }871 pub fn colon_token(&self) -> Option<SyntaxToken> {872 support::token(&self.syntax, T![:])873 }874 pub fn destruct(&self) -> Option<Destruct> {875 support::child(&self.syntax)876 }877 pub fn assign_token(&self) -> Option<SyntaxToken> {878 support::token(&self.syntax, T![=])879 }880 pub fn expr(&self) -> Option<Expr> {881 support::child(&self.syntax)882 }883}884885#[derive(Debug, Clone, PartialEq, Eq, Hash)]886pub struct DestructRest {887 pub(crate) syntax: SyntaxNode,888}889impl DestructRest {890 pub fn dotdotdot_token(&self) -> Option<SyntaxToken> {891 support::token(&self.syntax, T![...])892 }893 pub fn into(&self) -> Option<Name> {894 support::child(&self.syntax)895 }896}897898#[derive(Debug, Clone, PartialEq, Eq, Hash)]899pub struct DestructArrayElement {900 pub(crate) syntax: SyntaxNode,901}902impl DestructArrayElement {903 pub fn destruct(&self) -> Option<Destruct> {904 support::child(&self.syntax)905 }906}907908#[derive(Debug, Clone, PartialEq, Eq, Hash)]909pub enum Expr {910 ExprBinary(ExprBinary),911 ExprUnary(ExprUnary),912 ExprSlice(ExprSlice),913 ExprIndex(ExprIndex),914 ExprIndexExpr(ExprIndexExpr),915 ExprApply(ExprApply),916 ExprObjExtend(ExprObjExtend),917 ExprParened(ExprParened),918 ExprIntrinsicThisFile(ExprIntrinsicThisFile),919 ExprIntrinsicId(ExprIntrinsicId),920 ExprIntrinsic(ExprIntrinsic),921 ExprString(ExprString),922 ExprNumber(ExprNumber),923 ExprLiteral(ExprLiteral),924 ExprArray(ExprArray),925 ExprObject(ExprObject),926 ExprArrayComp(ExprArrayComp),927 ExprImport(ExprImport),928 ExprVar(ExprVar),929 ExprLocal(ExprLocal),930 ExprIfThenElse(ExprIfThenElse),931 ExprFunction(ExprFunction),932 ExprAssert(ExprAssert),933 ExprError(ExprError),934}935936#[derive(Debug, Clone, PartialEq, Eq, Hash)]937pub enum ObjBody {938 ObjBodyComp(ObjBodyComp),939 ObjBodyMemberList(ObjBodyMemberList),940}941942#[derive(Debug, Clone, PartialEq, Eq, Hash)]943pub enum CompSpec {944 ForSpec(ForSpec),945 IfSpec(IfSpec),946}947948#[derive(Debug, Clone, PartialEq, Eq, Hash)]949pub enum Bind {950 BindDestruct(BindDestruct),951 BindFunction(BindFunction),952}953954#[derive(Debug, Clone, PartialEq, Eq, Hash)]955pub enum Member {956 MemberBindStmt(MemberBindStmt),957 MemberAssertStmt(MemberAssertStmt),958 MemberField(MemberField),959}960961#[derive(Debug, Clone, PartialEq, Eq, Hash)]962pub enum Field {963 FieldNormal(FieldNormal),964 FieldMethod(FieldMethod),965}966967#[derive(Debug, Clone, PartialEq, Eq, Hash)]968pub enum FieldName {969 FieldNameFixed(FieldNameFixed),970 FieldNameDynamic(FieldNameDynamic),971}972973#[derive(Debug, Clone, PartialEq, Eq, Hash)]974pub enum Destruct {975 DestructFull(DestructFull),976 DestructSkip(DestructSkip),977 DestructArray(DestructArray),978 DestructObject(DestructObject),979}980981#[derive(Debug, Clone, PartialEq, Eq, Hash)]982pub enum DestructArrayPart {983 DestructArrayElement(DestructArrayElement),984 DestructRest(DestructRest),985}986987#[derive(Debug, Clone, PartialEq, Eq, Hash)]988pub struct BinaryOperator {989 syntax: SyntaxToken,990 kind: BinaryOperatorKind,991}992993#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]994pub enum BinaryOperatorKind {995 Or,996 And,997 BitOr,998 BitXor,999 BitAnd,1000 Eq,1001 Ne,1002 Lt,1003 Gt,1004 Le,1005 Ge,1006 InKw,1007 Lhs,1008 Rhs,1009 Plus,1010 Minus,1011 Mul,1012 Div,1013 Modulo,1014 MetaObjectApply,1015 ErrorNoOperator,1016}10171018#[derive(Debug, Clone, PartialEq, Eq, Hash)]1019pub struct UnaryOperator {1020 syntax: SyntaxToken,1021 kind: UnaryOperatorKind,1022}10231024#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]1025pub enum UnaryOperatorKind {1026 Minus,1027 Not,1028 BitNot,1029}10301031#[derive(Debug, Clone, PartialEq, Eq, Hash)]1032pub struct Literal {1033 syntax: SyntaxToken,1034 kind: LiteralKind,1035}10361037#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]1038pub enum LiteralKind {1039 NullKw,1040 TrueKw,1041 FalseKw,1042 SelfKw,1043 Dollar,1044 SuperKw,1045}10461047#[derive(Debug, Clone, PartialEq, Eq, Hash)]1048pub struct Text {1049 syntax: SyntaxToken,1050 kind: TextKind,1051}10521053#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]1054pub enum TextKind {1055 StringDouble,1056 ErrorStringDoubleUnterminated,1057 StringSingle,1058 ErrorStringSingleUnterminated,1059 StringDoubleVerbatim,1060 ErrorStringDoubleVerbatimUnterminated,1061 StringSingleVerbatim,1062 ErrorStringSingleVerbatimUnterminated,1063 ErrorStringVerbatimMissingQuotes,1064 StringBlock,1065 ErrorStringBlockUnexpectedEnd,1066 ErrorStringBlockMissingNewLine,1067 ErrorStringBlockMissingTermination,1068 ErrorStringBlockMissingIndent,1069}10701071#[derive(Debug, Clone, PartialEq, Eq, Hash)]1072pub struct Number {1073 syntax: SyntaxToken,1074 kind: NumberKind,1075}10761077#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]1078pub enum NumberKind {1079 Float,1080 ErrorFloatJunkAfterPoint,1081 ErrorFloatJunkAfterExponent,1082 ErrorFloatJunkAfterExponentSign,1083}10841085#[derive(Debug, Clone, PartialEq, Eq, Hash)]1086pub struct ImportKind {1087 syntax: SyntaxToken,1088 kind: ImportKindKind,1089}10901091#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]1092pub enum ImportKindKind {1093 ImportstrKw,1094 ImportbinKw,1095 ImportKw,1096}10971098#[derive(Debug, Clone, PartialEq, Eq, Hash)]1099pub struct Visibility {1100 syntax: SyntaxToken,1101 kind: VisibilityKind,1102}11031104#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]1105pub enum VisibilityKind {1106 Coloncoloncolon,1107 Coloncolon,1108 Colon,1109}11101111#[derive(Debug, Clone, PartialEq, Eq, Hash)]1112pub struct Trivia {1113 syntax: SyntaxToken,1114 kind: TriviaKind,1115}11161117#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]1118pub enum TriviaKind {1119 Whitespace,1120 MultiLineComment,1121 ErrorCommentTooShort,1122 ErrorCommentUnterminated,1123 SingleLineHashComment,1124 SingleLineSlashComment,1125}11261127#[derive(Debug, Clone, PartialEq, Eq, Hash)]1128pub struct ParsingError {1129 syntax: SyntaxToken,1130 kind: ParsingErrorKind,1131}11321133#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]1134pub enum ParsingErrorKind {1135 ErrorMissingToken,1136 ErrorUnexpectedToken,1137}1138impl AstNode for SourceFile {1139 fn can_cast(kind: SyntaxKind) -> bool {1140 kind == SOURCE_FILE1141 }1142 fn cast(syntax: SyntaxNode) -> Option<Self> {1143 if Self::can_cast(syntax.kind()) {1144 Some(Self { syntax })1145 } else {1146 None1147 }1148 }1149 fn syntax(&self) -> &SyntaxNode {1150 &self.syntax1151 }1152}1153impl AstNode for ExprBinary {1154 fn can_cast(kind: SyntaxKind) -> bool {1155 kind == EXPR_BINARY1156 }1157 fn cast(syntax: SyntaxNode) -> Option<Self> {1158 if Self::can_cast(syntax.kind()) {1159 Some(Self { syntax })1160 } else {1161 None1162 }1163 }1164 fn syntax(&self) -> &SyntaxNode {1165 &self.syntax1166 }1167}1168impl AstNode for LhsExpr {1169 fn can_cast(kind: SyntaxKind) -> bool {1170 kind == LHS_EXPR1171 }1172 fn cast(syntax: SyntaxNode) -> Option<Self> {1173 if Self::can_cast(syntax.kind()) {1174 Some(Self { syntax })1175 } else {1176 None1177 }1178 }1179 fn syntax(&self) -> &SyntaxNode {1180 &self.syntax1181 }1182}1183impl AstNode for ExprUnary {1184 fn can_cast(kind: SyntaxKind) -> bool {1185 kind == EXPR_UNARY1186 }1187 fn cast(syntax: SyntaxNode) -> Option<Self> {1188 if Self::can_cast(syntax.kind()) {1189 Some(Self { syntax })1190 } else {1191 None1192 }1193 }1194 fn syntax(&self) -> &SyntaxNode {1195 &self.syntax1196 }1197}1198impl AstNode for ExprSlice {1199 fn can_cast(kind: SyntaxKind) -> bool {1200 kind == EXPR_SLICE1201 }1202 fn cast(syntax: SyntaxNode) -> Option<Self> {1203 if Self::can_cast(syntax.kind()) {1204 Some(Self { syntax })1205 } else {1206 None1207 }1208 }1209 fn syntax(&self) -> &SyntaxNode {1210 &self.syntax1211 }1212}1213impl AstNode for SliceDesc {1214 fn can_cast(kind: SyntaxKind) -> bool {1215 kind == SLICE_DESC1216 }1217 fn cast(syntax: SyntaxNode) -> Option<Self> {1218 if Self::can_cast(syntax.kind()) {1219 Some(Self { syntax })1220 } else {1221 None1222 }1223 }1224 fn syntax(&self) -> &SyntaxNode {1225 &self.syntax1226 }1227}1228impl AstNode for ExprIndex {1229 fn can_cast(kind: SyntaxKind) -> bool {1230 kind == EXPR_INDEX1231 }1232 fn cast(syntax: SyntaxNode) -> Option<Self> {1233 if Self::can_cast(syntax.kind()) {1234 Some(Self { syntax })1235 } else {1236 None1237 }1238 }1239 fn syntax(&self) -> &SyntaxNode {1240 &self.syntax1241 }1242}1243impl AstNode for Name {1244 fn can_cast(kind: SyntaxKind) -> bool {1245 kind == NAME1246 }1247 fn cast(syntax: SyntaxNode) -> Option<Self> {1248 if Self::can_cast(syntax.kind()) {1249 Some(Self { syntax })1250 } else {1251 None1252 }1253 }1254 fn syntax(&self) -> &SyntaxNode {1255 &self.syntax1256 }1257}1258impl AstNode for ExprIndexExpr {1259 fn can_cast(kind: SyntaxKind) -> bool {1260 kind == EXPR_INDEX_EXPR1261 }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 {1270 &self.syntax1271 }1272}1273impl AstNode for ExprApply {1274 fn can_cast(kind: SyntaxKind) -> bool {1275 kind == EXPR_APPLY1276 }1277 fn cast(syntax: SyntaxNode) -> Option<Self> {1278 if Self::can_cast(syntax.kind()) {1279 Some(Self { syntax })1280 } else {1281 None1282 }1283 }1284 fn syntax(&self) -> &SyntaxNode {1285 &self.syntax1286 }1287}1288impl AstNode for ArgsDesc {1289 fn can_cast(kind: SyntaxKind) -> bool {1290 kind == ARGS_DESC1291 }1292 fn cast(syntax: SyntaxNode) -> Option<Self> {1293 if Self::can_cast(syntax.kind()) {1294 Some(Self { syntax })1295 } else {1296 None1297 }1298 }1299 fn syntax(&self) -> &SyntaxNode {1300 &self.syntax1301 }1302}1303impl AstNode for ExprObjExtend {1304 fn can_cast(kind: SyntaxKind) -> bool {1305 kind == EXPR_OBJ_EXTEND1306 }1307 fn cast(syntax: SyntaxNode) -> Option<Self> {1308 if Self::can_cast(syntax.kind()) {1309 Some(Self { syntax })1310 } else {1311 None1312 }1313 }1314 fn syntax(&self) -> &SyntaxNode {1315 &self.syntax1316 }1317}1318impl AstNode for ExprParened {1319 fn can_cast(kind: SyntaxKind) -> bool {1320 kind == EXPR_PARENED1321 }1322 fn cast(syntax: SyntaxNode) -> Option<Self> {1323 if Self::can_cast(syntax.kind()) {1324 Some(Self { syntax })1325 } else {1326 None1327 }1328 }1329 fn syntax(&self) -> &SyntaxNode {1330 &self.syntax1331 }1332}1333impl AstNode for ExprLiteral {1334 fn can_cast(kind: SyntaxKind) -> bool {1335 kind == EXPR_LITERAL1336 }1337 fn cast(syntax: SyntaxNode) -> Option<Self> {1338 if Self::can_cast(syntax.kind()) {1339 Some(Self { syntax })1340 } else {1341 None1342 }1343 }1344 fn syntax(&self) -> &SyntaxNode {1345 &self.syntax1346 }1347}1348impl AstNode for ExprIntrinsicThisFile {1349 fn can_cast(kind: SyntaxKind) -> bool {1350 kind == EXPR_INTRINSIC_THIS_FILE1351 }1352 fn cast(syntax: SyntaxNode) -> Option<Self> {1353 if Self::can_cast(syntax.kind()) {1354 Some(Self { syntax })1355 } else {1356 None1357 }1358 }1359 fn syntax(&self) -> &SyntaxNode {1360 &self.syntax1361 }1362}1363impl AstNode for ExprIntrinsicId {1364 fn can_cast(kind: SyntaxKind) -> bool {1365 kind == EXPR_INTRINSIC_ID1366 }1367 fn cast(syntax: SyntaxNode) -> Option<Self> {1368 if Self::can_cast(syntax.kind()) {1369 Some(Self { syntax })1370 } else {1371 None1372 }1373 }1374 fn syntax(&self) -> &SyntaxNode {1375 &self.syntax1376 }1377}1378impl AstNode for ExprIntrinsic {1379 fn can_cast(kind: SyntaxKind) -> bool {1380 kind == EXPR_INTRINSIC1381 }1382 fn cast(syntax: SyntaxNode) -> Option<Self> {1383 if Self::can_cast(syntax.kind()) {1384 Some(Self { syntax })1385 } else {1386 None1387 }1388 }1389 fn syntax(&self) -> &SyntaxNode {1390 &self.syntax1391 }1392}1393impl AstNode for ExprString {1394 fn can_cast(kind: SyntaxKind) -> bool {1395 kind == EXPR_STRING1396 }1397 fn cast(syntax: SyntaxNode) -> Option<Self> {1398 if Self::can_cast(syntax.kind()) {1399 Some(Self { syntax })1400 } else {1401 None1402 }1403 }1404 fn syntax(&self) -> &SyntaxNode {1405 &self.syntax1406 }1407}1408impl AstNode for ExprNumber {1409 fn can_cast(kind: SyntaxKind) -> bool {1410 kind == EXPR_NUMBER1411 }1412 fn cast(syntax: SyntaxNode) -> Option<Self> {1413 if Self::can_cast(syntax.kind()) {1414 Some(Self { syntax })1415 } else {1416 None1417 }1418 }1419 fn syntax(&self) -> &SyntaxNode {1420 &self.syntax1421 }1422}1423impl AstNode for ExprArray {1424 fn can_cast(kind: SyntaxKind) -> bool {1425 kind == EXPR_ARRAY1426 }1427 fn cast(syntax: SyntaxNode) -> Option<Self> {1428 if Self::can_cast(syntax.kind()) {1429 Some(Self { syntax })1430 } else {1431 None1432 }1433 }1434 fn syntax(&self) -> &SyntaxNode {1435 &self.syntax1436 }1437}1438impl AstNode for ExprObject {1439 fn can_cast(kind: SyntaxKind) -> bool {1440 kind == EXPR_OBJECT1441 }1442 fn cast(syntax: SyntaxNode) -> Option<Self> {1443 if Self::can_cast(syntax.kind()) {1444 Some(Self { syntax })1445 } else {1446 None1447 }1448 }1449 fn syntax(&self) -> &SyntaxNode {1450 &self.syntax1451 }1452}1453impl AstNode for ExprArrayComp {1454 fn can_cast(kind: SyntaxKind) -> bool {1455 kind == EXPR_ARRAY_COMP1456 }1457 fn cast(syntax: SyntaxNode) -> Option<Self> {1458 if Self::can_cast(syntax.kind()) {1459 Some(Self { syntax })1460 } else {1461 None1462 }1463 }1464 fn syntax(&self) -> &SyntaxNode {1465 &self.syntax1466 }1467}1468impl AstNode for ExprImport {1469 fn can_cast(kind: SyntaxKind) -> bool {1470 kind == EXPR_IMPORT1471 }1472 fn cast(syntax: SyntaxNode) -> Option<Self> {1473 if Self::can_cast(syntax.kind()) {1474 Some(Self { syntax })1475 } else {1476 None1477 }1478 }1479 fn syntax(&self) -> &SyntaxNode {1480 &self.syntax1481 }1482}1483impl AstNode for ExprVar {1484 fn can_cast(kind: SyntaxKind) -> bool {1485 kind == EXPR_VAR1486 }1487 fn cast(syntax: SyntaxNode) -> Option<Self> {1488 if Self::can_cast(syntax.kind()) {1489 Some(Self { syntax })1490 } else {1491 None1492 }1493 }1494 fn syntax(&self) -> &SyntaxNode {1495 &self.syntax1496 }1497}1498impl AstNode for ExprLocal {1499 fn can_cast(kind: SyntaxKind) -> bool {1500 kind == EXPR_LOCAL1501 }1502 fn cast(syntax: SyntaxNode) -> Option<Self> {1503 if Self::can_cast(syntax.kind()) {1504 Some(Self { syntax })1505 } else {1506 None1507 }1508 }1509 fn syntax(&self) -> &SyntaxNode {1510 &self.syntax1511 }1512}1513impl AstNode for ExprIfThenElse {1514 fn can_cast(kind: SyntaxKind) -> bool {1515 kind == EXPR_IF_THEN_ELSE1516 }1517 fn cast(syntax: SyntaxNode) -> Option<Self> {1518 if Self::can_cast(syntax.kind()) {1519 Some(Self { syntax })1520 } else {1521 None1522 }1523 }1524 fn syntax(&self) -> &SyntaxNode {1525 &self.syntax1526 }1527}1528impl AstNode for TrueExpr {1529 fn can_cast(kind: SyntaxKind) -> bool {1530 kind == TRUE_EXPR1531 }1532 fn cast(syntax: SyntaxNode) -> Option<Self> {1533 if Self::can_cast(syntax.kind()) {1534 Some(Self { syntax })1535 } else {1536 None1537 }1538 }1539 fn syntax(&self) -> &SyntaxNode {1540 &self.syntax1541 }1542}1543impl AstNode for FalseExpr {1544 fn can_cast(kind: SyntaxKind) -> bool {1545 kind == FALSE_EXPR1546 }1547 fn cast(syntax: SyntaxNode) -> Option<Self> {1548 if Self::can_cast(syntax.kind()) {1549 Some(Self { syntax })1550 } else {1551 None1552 }1553 }1554 fn syntax(&self) -> &SyntaxNode {1555 &self.syntax1556 }1557}1558impl AstNode for ExprFunction {1559 fn can_cast(kind: SyntaxKind) -> bool {1560 kind == EXPR_FUNCTION1561 }1562 fn cast(syntax: SyntaxNode) -> Option<Self> {1563 if Self::can_cast(syntax.kind()) {1564 Some(Self { syntax })1565 } else {1566 None1567 }1568 }1569 fn syntax(&self) -> &SyntaxNode {1570 &self.syntax1571 }1572}1573impl AstNode for ParamsDesc {1574 fn can_cast(kind: SyntaxKind) -> bool {1575 kind == PARAMS_DESC1576 }1577 fn cast(syntax: SyntaxNode) -> Option<Self> {1578 if Self::can_cast(syntax.kind()) {1579 Some(Self { syntax })1580 } else {1581 None1582 }1583 }1584 fn syntax(&self) -> &SyntaxNode {1585 &self.syntax1586 }1587}1588impl AstNode for ExprAssert {1589 fn can_cast(kind: SyntaxKind) -> bool {1590 kind == EXPR_ASSERT1591 }1592 fn cast(syntax: SyntaxNode) -> Option<Self> {1593 if Self::can_cast(syntax.kind()) {1594 Some(Self { syntax })1595 } else {1596 None1597 }1598 }1599 fn syntax(&self) -> &SyntaxNode {1600 &self.syntax1601 }1602}1603impl AstNode for Assertion {1604 fn can_cast(kind: SyntaxKind) -> bool {1605 kind == ASSERTION1606 }1607 fn cast(syntax: SyntaxNode) -> Option<Self> {1608 if Self::can_cast(syntax.kind()) {1609 Some(Self { syntax })1610 } else {1611 None1612 }1613 }1614 fn syntax(&self) -> &SyntaxNode {1615 &self.syntax1616 }1617}1618impl AstNode for ExprError {1619 fn can_cast(kind: SyntaxKind) -> bool {1620 kind == EXPR_ERROR1621 }1622 fn cast(syntax: SyntaxNode) -> Option<Self> {1623 if Self::can_cast(syntax.kind()) {1624 Some(Self { syntax })1625 } else {1626 None1627 }1628 }1629 fn syntax(&self) -> &SyntaxNode {1630 &self.syntax1631 }1632}1633impl AstNode for SliceDescEnd {1634 fn can_cast(kind: SyntaxKind) -> bool {1635 kind == SLICE_DESC_END1636 }1637 fn cast(syntax: SyntaxNode) -> Option<Self> {1638 if Self::can_cast(syntax.kind()) {1639 Some(Self { syntax })1640 } else {1641 None1642 }1643 }1644 fn syntax(&self) -> &SyntaxNode {1645 &self.syntax1646 }1647}1648impl AstNode for SliceDescStep {1649 fn can_cast(kind: SyntaxKind) -> bool {1650 kind == SLICE_DESC_STEP1651 }1652 fn cast(syntax: SyntaxNode) -> Option<Self> {1653 if Self::can_cast(syntax.kind()) {1654 Some(Self { syntax })1655 } else {1656 None1657 }1658 }1659 fn syntax(&self) -> &SyntaxNode {1660 &self.syntax1661 }1662}1663impl AstNode for Arg {1664 fn can_cast(kind: SyntaxKind) -> bool {1665 kind == ARG1666 }1667 fn cast(syntax: SyntaxNode) -> Option<Self> {1668 if Self::can_cast(syntax.kind()) {1669 Some(Self { syntax })1670 } else {1671 None1672 }1673 }1674 fn syntax(&self) -> &SyntaxNode {1675 &self.syntax1676 }1677}1678impl AstNode for ObjBodyComp {1679 fn can_cast(kind: SyntaxKind) -> bool {1680 kind == OBJ_BODY_COMP1681 }1682 fn cast(syntax: SyntaxNode) -> Option<Self> {1683 if Self::can_cast(syntax.kind()) {1684 Some(Self { syntax })1685 } else {1686 None1687 }1688 }1689 fn syntax(&self) -> &SyntaxNode {1690 &self.syntax1691 }1692}1693impl AstNode for ObjLocalPostComma {1694 fn can_cast(kind: SyntaxKind) -> bool {1695 kind == OBJ_LOCAL_POST_COMMA1696 }1697 fn cast(syntax: SyntaxNode) -> Option<Self> {1698 if Self::can_cast(syntax.kind()) {1699 Some(Self { syntax })1700 } else {1701 None1702 }1703 }1704 fn syntax(&self) -> &SyntaxNode {1705 &self.syntax1706 }1707}1708impl AstNode for ObjLocalPreComma {1709 fn can_cast(kind: SyntaxKind) -> bool {1710 kind == OBJ_LOCAL_PRE_COMMA1711 }1712 fn cast(syntax: SyntaxNode) -> Option<Self> {1713 if Self::can_cast(syntax.kind()) {1714 Some(Self { syntax })1715 } else {1716 None1717 }1718 }1719 fn syntax(&self) -> &SyntaxNode {1720 &self.syntax1721 }1722}1723impl AstNode for ObjBodyMemberList {1724 fn can_cast(kind: SyntaxKind) -> bool {1725 kind == OBJ_BODY_MEMBER_LIST1726 }1727 fn cast(syntax: SyntaxNode) -> Option<Self> {1728 if Self::can_cast(syntax.kind()) {1729 Some(Self { syntax })1730 } else {1731 None1732 }1733 }1734 fn syntax(&self) -> &SyntaxNode {1735 &self.syntax1736 }1737}1738impl AstNode for ObjLocal {1739 fn can_cast(kind: SyntaxKind) -> bool {1740 kind == OBJ_LOCAL1741 }1742 fn cast(syntax: SyntaxNode) -> Option<Self> {1743 if Self::can_cast(syntax.kind()) {1744 Some(Self { syntax })1745 } else {1746 None1747 }1748 }1749 fn syntax(&self) -> &SyntaxNode {1750 &self.syntax1751 }1752}1753impl AstNode for MemberBindStmt {1754 fn can_cast(kind: SyntaxKind) -> bool {1755 kind == MEMBER_BIND_STMT1756 }1757 fn cast(syntax: SyntaxNode) -> Option<Self> {1758 if Self::can_cast(syntax.kind()) {1759 Some(Self { syntax })1760 } else {1761 None1762 }1763 }1764 fn syntax(&self) -> &SyntaxNode {1765 &self.syntax1766 }1767}1768impl AstNode for MemberAssertStmt {1769 fn can_cast(kind: SyntaxKind) -> bool {1770 kind == MEMBER_ASSERT_STMT1771 }1772 fn cast(syntax: SyntaxNode) -> Option<Self> {1773 if Self::can_cast(syntax.kind()) {1774 Some(Self { syntax })1775 } else {1776 None1777 }1778 }1779 fn syntax(&self) -> &SyntaxNode {1780 &self.syntax1781 }1782}1783impl AstNode for MemberField {1784 fn can_cast(kind: SyntaxKind) -> bool {1785 kind == MEMBER_FIELD1786 }1787 fn cast(syntax: SyntaxNode) -> Option<Self> {1788 if Self::can_cast(syntax.kind()) {1789 Some(Self { syntax })1790 } else {1791 None1792 }1793 }1794 fn syntax(&self) -> &SyntaxNode {1795 &self.syntax1796 }1797}1798impl AstNode for FieldNormal {1799 fn can_cast(kind: SyntaxKind) -> bool {1800 kind == FIELD_NORMAL1801 }1802 fn cast(syntax: SyntaxNode) -> Option<Self> {1803 if Self::can_cast(syntax.kind()) {1804 Some(Self { syntax })1805 } else {1806 None1807 }1808 }1809 fn syntax(&self) -> &SyntaxNode {1810 &self.syntax1811 }1812}1813impl AstNode for FieldMethod {1814 fn can_cast(kind: SyntaxKind) -> bool {1815 kind == FIELD_METHOD1816 }1817 fn cast(syntax: SyntaxNode) -> Option<Self> {1818 if Self::can_cast(syntax.kind()) {1819 Some(Self { syntax })1820 } else {1821 None1822 }1823 }1824 fn syntax(&self) -> &SyntaxNode {1825 &self.syntax1826 }1827}1828impl AstNode for FieldNameFixed {1829 fn can_cast(kind: SyntaxKind) -> bool {1830 kind == FIELD_NAME_FIXED1831 }1832 fn cast(syntax: SyntaxNode) -> Option<Self> {1833 if Self::can_cast(syntax.kind()) {1834 Some(Self { syntax })1835 } else {1836 None1837 }1838 }1839 fn syntax(&self) -> &SyntaxNode {1840 &self.syntax1841 }1842}1843impl AstNode for FieldNameDynamic {1844 fn can_cast(kind: SyntaxKind) -> bool {1845 kind == FIELD_NAME_DYNAMIC1846 }1847 fn cast(syntax: SyntaxNode) -> Option<Self> {1848 if Self::can_cast(syntax.kind()) {1849 Some(Self { syntax })1850 } else {1851 None1852 }1853 }1854 fn syntax(&self) -> &SyntaxNode {1855 &self.syntax1856 }1857}1858impl AstNode for ForSpec {1859 fn can_cast(kind: SyntaxKind) -> bool {1860 kind == FOR_SPEC1861 }1862 fn cast(syntax: SyntaxNode) -> Option<Self> {1863 if Self::can_cast(syntax.kind()) {1864 Some(Self { syntax })1865 } else {1866 None1867 }1868 }1869 fn syntax(&self) -> &SyntaxNode {1870 &self.syntax1871 }1872}1873impl AstNode for IfSpec {1874 fn can_cast(kind: SyntaxKind) -> bool {1875 kind == IF_SPEC1876 }1877 fn cast(syntax: SyntaxNode) -> Option<Self> {1878 if Self::can_cast(syntax.kind()) {1879 Some(Self { syntax })1880 } else {1881 None1882 }1883 }1884 fn syntax(&self) -> &SyntaxNode {1885 &self.syntax1886 }1887}1888impl AstNode for BindDestruct {1889 fn can_cast(kind: SyntaxKind) -> bool {1890 kind == BIND_DESTRUCT1891 }1892 fn cast(syntax: SyntaxNode) -> Option<Self> {1893 if Self::can_cast(syntax.kind()) {1894 Some(Self { syntax })1895 } else {1896 None1897 }1898 }1899 fn syntax(&self) -> &SyntaxNode {1900 &self.syntax1901 }1902}1903impl AstNode for BindFunction {1904 fn can_cast(kind: SyntaxKind) -> bool {1905 kind == BIND_FUNCTION1906 }1907 fn cast(syntax: SyntaxNode) -> Option<Self> {1908 if Self::can_cast(syntax.kind()) {1909 Some(Self { syntax })1910 } else {1911 None1912 }1913 }1914 fn syntax(&self) -> &SyntaxNode {1915 &self.syntax1916 }1917}1918impl AstNode for Param {1919 fn can_cast(kind: SyntaxKind) -> bool {1920 kind == PARAM1921 }1922 fn cast(syntax: SyntaxNode) -> Option<Self> {1923 if Self::can_cast(syntax.kind()) {1924 Some(Self { syntax })1925 } else {1926 None1927 }1928 }1929 fn syntax(&self) -> &SyntaxNode {1930 &self.syntax1931 }1932}1933impl AstNode for DestructFull {1934 fn can_cast(kind: SyntaxKind) -> bool {1935 kind == DESTRUCT_FULL1936 }1937 fn cast(syntax: SyntaxNode) -> Option<Self> {1938 if Self::can_cast(syntax.kind()) {1939 Some(Self { syntax })1940 } else {1941 None1942 }1943 }1944 fn syntax(&self) -> &SyntaxNode {1945 &self.syntax1946 }1947}1948impl AstNode for DestructSkip {1949 fn can_cast(kind: SyntaxKind) -> bool {1950 kind == DESTRUCT_SKIP1951 }1952 fn cast(syntax: SyntaxNode) -> Option<Self> {1953 if Self::can_cast(syntax.kind()) {1954 Some(Self { syntax })1955 } else {1956 None1957 }1958 }1959 fn syntax(&self) -> &SyntaxNode {1960 &self.syntax1961 }1962}1963impl AstNode for DestructArray {1964 fn can_cast(kind: SyntaxKind) -> bool {1965 kind == DESTRUCT_ARRAY1966 }1967 fn cast(syntax: SyntaxNode) -> Option<Self> {1968 if Self::can_cast(syntax.kind()) {1969 Some(Self { syntax })1970 } else {1971 None1972 }1973 }1974 fn syntax(&self) -> &SyntaxNode {1975 &self.syntax1976 }1977}1978impl AstNode for DestructObject {1979 fn can_cast(kind: SyntaxKind) -> bool {1980 kind == DESTRUCT_OBJECT1981 }1982 fn cast(syntax: SyntaxNode) -> Option<Self> {1983 if Self::can_cast(syntax.kind()) {1984 Some(Self { syntax })1985 } else {1986 None1987 }1988 }1989 fn syntax(&self) -> &SyntaxNode {1990 &self.syntax1991 }1992}1993impl AstNode for DestructObjectField {1994 fn can_cast(kind: SyntaxKind) -> bool {1995 kind == DESTRUCT_OBJECT_FIELD1996 }1997 fn cast(syntax: SyntaxNode) -> Option<Self> {1998 if Self::can_cast(syntax.kind()) {1999 Some(Self { syntax })2000 } else {2001 None2002 }2003 }2004 fn syntax(&self) -> &SyntaxNode {2005 &self.syntax2006 }2007}2008impl AstNode for DestructRest {2009 fn can_cast(kind: SyntaxKind) -> bool {2010 kind == DESTRUCT_REST2011 }2012 fn cast(syntax: SyntaxNode) -> Option<Self> {2013 if Self::can_cast(syntax.kind()) {2014 Some(Self { syntax })2015 } else {2016 None2017 }2018 }2019 fn syntax(&self) -> &SyntaxNode {2020 &self.syntax2021 }2022}2023impl AstNode for DestructArrayElement {2024 fn can_cast(kind: SyntaxKind) -> bool {2025 kind == DESTRUCT_ARRAY_ELEMENT2026 }2027 fn cast(syntax: SyntaxNode) -> Option<Self> {2028 if Self::can_cast(syntax.kind()) {2029 Some(Self { syntax })2030 } else {2031 None2032 }2033 }2034 fn syntax(&self) -> &SyntaxNode {2035 &self.syntax2036 }2037}2038impl From<ExprBinary> for Expr {2039 fn from(node: ExprBinary) -> Expr {2040 Expr::ExprBinary(node)2041 }2042}2043impl From<ExprUnary> for Expr {2044 fn from(node: ExprUnary) -> Expr {2045 Expr::ExprUnary(node)2046 }2047}2048impl From<ExprSlice> for Expr {2049 fn from(node: ExprSlice) -> Expr {2050 Expr::ExprSlice(node)2051 }2052}2053impl From<ExprIndex> for Expr {2054 fn from(node: ExprIndex) -> Expr {2055 Expr::ExprIndex(node)2056 }2057}2058impl From<ExprIndexExpr> for Expr {2059 fn from(node: ExprIndexExpr) -> Expr {2060 Expr::ExprIndexExpr(node)2061 }2062}2063impl From<ExprApply> for Expr {2064 fn from(node: ExprApply) -> Expr {2065 Expr::ExprApply(node)2066 }2067}2068impl From<ExprObjExtend> for Expr {2069 fn from(node: ExprObjExtend) -> Expr {2070 Expr::ExprObjExtend(node)2071 }2072}2073impl From<ExprParened> for Expr {2074 fn from(node: ExprParened) -> Expr {2075 Expr::ExprParened(node)2076 }2077}2078impl From<ExprIntrinsicThisFile> for Expr {2079 fn from(node: ExprIntrinsicThisFile) -> Expr {2080 Expr::ExprIntrinsicThisFile(node)2081 }2082}2083impl From<ExprIntrinsicId> for Expr {2084 fn from(node: ExprIntrinsicId) -> Expr {2085 Expr::ExprIntrinsicId(node)2086 }2087}2088impl From<ExprIntrinsic> for Expr {2089 fn from(node: ExprIntrinsic) -> Expr {2090 Expr::ExprIntrinsic(node)2091 }2092}2093impl From<ExprString> for Expr {2094 fn from(node: ExprString) -> Expr {2095 Expr::ExprString(node)2096 }2097}2098impl From<ExprNumber> for Expr {2099 fn from(node: ExprNumber) -> Expr {2100 Expr::ExprNumber(node)2101 }2102}2103impl From<ExprLiteral> for Expr {2104 fn from(node: ExprLiteral) -> Expr {2105 Expr::ExprLiteral(node)2106 }2107}2108impl From<ExprArray> for Expr {2109 fn from(node: ExprArray) -> Expr {2110 Expr::ExprArray(node)2111 }2112}2113impl From<ExprObject> for Expr {2114 fn from(node: ExprObject) -> Expr {2115 Expr::ExprObject(node)2116 }2117}2118impl From<ExprArrayComp> for Expr {2119 fn from(node: ExprArrayComp) -> Expr {2120 Expr::ExprArrayComp(node)2121 }2122}2123impl From<ExprImport> for Expr {2124 fn from(node: ExprImport) -> Expr {2125 Expr::ExprImport(node)2126 }2127}2128impl From<ExprVar> for Expr {2129 fn from(node: ExprVar) -> Expr {2130 Expr::ExprVar(node)2131 }2132}2133impl From<ExprLocal> for Expr {2134 fn from(node: ExprLocal) -> Expr {2135 Expr::ExprLocal(node)2136 }2137}2138impl From<ExprIfThenElse> for Expr {2139 fn from(node: ExprIfThenElse) -> Expr {2140 Expr::ExprIfThenElse(node)2141 }2142}2143impl From<ExprFunction> for Expr {2144 fn from(node: ExprFunction) -> Expr {2145 Expr::ExprFunction(node)2146 }2147}2148impl From<ExprAssert> for Expr {2149 fn from(node: ExprAssert) -> Expr {2150 Expr::ExprAssert(node)2151 }2152}2153impl From<ExprError> for Expr {2154 fn from(node: ExprError) -> Expr {2155 Expr::ExprError(node)2156 }2157}2158impl AstNode for Expr {2159 fn can_cast(kind: SyntaxKind) -> bool {2160 match kind {2161 EXPR_BINARY2162 | EXPR_UNARY2163 | EXPR_SLICE2164 | EXPR_INDEX2165 | EXPR_INDEX_EXPR2166 | EXPR_APPLY2167 | EXPR_OBJ_EXTEND2168 | EXPR_PARENED2169 | EXPR_INTRINSIC_THIS_FILE2170 | EXPR_INTRINSIC_ID2171 | EXPR_INTRINSIC2172 | EXPR_STRING2173 | EXPR_NUMBER2174 | EXPR_LITERAL2175 | EXPR_ARRAY2176 | EXPR_OBJECT2177 | EXPR_ARRAY_COMP2178 | EXPR_IMPORT2179 | EXPR_VAR2180 | EXPR_LOCAL2181 | EXPR_IF_THEN_ELSE2182 | EXPR_FUNCTION2183 | EXPR_ASSERT2184 | EXPR_ERROR => true,2185 _ => false,2186 }2187 }2188 fn cast(syntax: SyntaxNode) -> Option<Self> {2189 let res = match syntax.kind() {2190 EXPR_BINARY => Expr::ExprBinary(ExprBinary { syntax }),2191 EXPR_UNARY => Expr::ExprUnary(ExprUnary { syntax }),2192 EXPR_SLICE => Expr::ExprSlice(ExprSlice { syntax }),2193 EXPR_INDEX => Expr::ExprIndex(ExprIndex { syntax }),2194 EXPR_INDEX_EXPR => Expr::ExprIndexExpr(ExprIndexExpr { syntax }),2195 EXPR_APPLY => Expr::ExprApply(ExprApply { syntax }),2196 EXPR_OBJ_EXTEND => Expr::ExprObjExtend(ExprObjExtend { syntax }),2197 EXPR_PARENED => Expr::ExprParened(ExprParened { syntax }),2198 EXPR_INTRINSIC_THIS_FILE => {2199 Expr::ExprIntrinsicThisFile(ExprIntrinsicThisFile { syntax })2200 }2201 EXPR_INTRINSIC_ID => Expr::ExprIntrinsicId(ExprIntrinsicId { syntax }),2202 EXPR_INTRINSIC => Expr::ExprIntrinsic(ExprIntrinsic { syntax }),2203 EXPR_STRING => Expr::ExprString(ExprString { syntax }),2204 EXPR_NUMBER => Expr::ExprNumber(ExprNumber { syntax }),2205 EXPR_LITERAL => Expr::ExprLiteral(ExprLiteral { syntax }),2206 EXPR_ARRAY => Expr::ExprArray(ExprArray { syntax }),2207 EXPR_OBJECT => Expr::ExprObject(ExprObject { syntax }),2208 EXPR_ARRAY_COMP => Expr::ExprArrayComp(ExprArrayComp { syntax }),2209 EXPR_IMPORT => Expr::ExprImport(ExprImport { syntax }),2210 EXPR_VAR => Expr::ExprVar(ExprVar { syntax }),2211 EXPR_LOCAL => Expr::ExprLocal(ExprLocal { syntax }),2212 EXPR_IF_THEN_ELSE => Expr::ExprIfThenElse(ExprIfThenElse { syntax }),2213 EXPR_FUNCTION => Expr::ExprFunction(ExprFunction { syntax }),2214 EXPR_ASSERT => Expr::ExprAssert(ExprAssert { syntax }),2215 EXPR_ERROR => Expr::ExprError(ExprError { syntax }),2216 _ => return None,2217 };2218 Some(res)2219 }2220 fn syntax(&self) -> &SyntaxNode {2221 match self {2222 Expr::ExprBinary(it) => &it.syntax,2223 Expr::ExprUnary(it) => &it.syntax,2224 Expr::ExprSlice(it) => &it.syntax,2225 Expr::ExprIndex(it) => &it.syntax,2226 Expr::ExprIndexExpr(it) => &it.syntax,2227 Expr::ExprApply(it) => &it.syntax,2228 Expr::ExprObjExtend(it) => &it.syntax,2229 Expr::ExprParened(it) => &it.syntax,2230 Expr::ExprIntrinsicThisFile(it) => &it.syntax,2231 Expr::ExprIntrinsicId(it) => &it.syntax,2232 Expr::ExprIntrinsic(it) => &it.syntax,2233 Expr::ExprString(it) => &it.syntax,2234 Expr::ExprNumber(it) => &it.syntax,2235 Expr::ExprLiteral(it) => &it.syntax,2236 Expr::ExprArray(it) => &it.syntax,2237 Expr::ExprObject(it) => &it.syntax,2238 Expr::ExprArrayComp(it) => &it.syntax,2239 Expr::ExprImport(it) => &it.syntax,2240 Expr::ExprVar(it) => &it.syntax,2241 Expr::ExprLocal(it) => &it.syntax,2242 Expr::ExprIfThenElse(it) => &it.syntax,2243 Expr::ExprFunction(it) => &it.syntax,2244 Expr::ExprAssert(it) => &it.syntax,2245 Expr::ExprError(it) => &it.syntax,2246 }2247 }2248}2249impl From<ObjBodyComp> for ObjBody {2250 fn from(node: ObjBodyComp) -> ObjBody {2251 ObjBody::ObjBodyComp(node)2252 }2253}2254impl From<ObjBodyMemberList> for ObjBody {2255 fn from(node: ObjBodyMemberList) -> ObjBody {2256 ObjBody::ObjBodyMemberList(node)2257 }2258}2259impl AstNode for ObjBody {2260 fn can_cast(kind: SyntaxKind) -> bool {2261 match kind {2262 OBJ_BODY_COMP | OBJ_BODY_MEMBER_LIST => true,2263 _ => false,2264 }2265 }2266 fn cast(syntax: SyntaxNode) -> Option<Self> {2267 let res = match syntax.kind() {2268 OBJ_BODY_COMP => ObjBody::ObjBodyComp(ObjBodyComp { syntax }),2269 OBJ_BODY_MEMBER_LIST => ObjBody::ObjBodyMemberList(ObjBodyMemberList { syntax }),2270 _ => return None,2271 };2272 Some(res)2273 }2274 fn syntax(&self) -> &SyntaxNode {2275 match self {2276 ObjBody::ObjBodyComp(it) => &it.syntax,2277 ObjBody::ObjBodyMemberList(it) => &it.syntax,2278 }2279 }2280}2281impl From<ForSpec> for CompSpec {2282 fn from(node: ForSpec) -> CompSpec {2283 CompSpec::ForSpec(node)2284 }2285}2286impl From<IfSpec> for CompSpec {2287 fn from(node: IfSpec) -> CompSpec {2288 CompSpec::IfSpec(node)2289 }2290}2291impl AstNode for CompSpec {2292 fn can_cast(kind: SyntaxKind) -> bool {2293 match kind {2294 FOR_SPEC | IF_SPEC => true,2295 _ => false,2296 }2297 }2298 fn cast(syntax: SyntaxNode) -> Option<Self> {2299 let res = match syntax.kind() {2300 FOR_SPEC => CompSpec::ForSpec(ForSpec { syntax }),2301 IF_SPEC => CompSpec::IfSpec(IfSpec { syntax }),2302 _ => return None,2303 };2304 Some(res)2305 }2306 fn syntax(&self) -> &SyntaxNode {2307 match self {2308 CompSpec::ForSpec(it) => &it.syntax,2309 CompSpec::IfSpec(it) => &it.syntax,2310 }2311 }2312}2313impl From<BindDestruct> for Bind {2314 fn from(node: BindDestruct) -> Bind {2315 Bind::BindDestruct(node)2316 }2317}2318impl From<BindFunction> for Bind {2319 fn from(node: BindFunction) -> Bind {2320 Bind::BindFunction(node)2321 }2322}2323impl AstNode for Bind {2324 fn can_cast(kind: SyntaxKind) -> bool {2325 match kind {2326 BIND_DESTRUCT | BIND_FUNCTION => true,2327 _ => false,2328 }2329 }2330 fn cast(syntax: SyntaxNode) -> Option<Self> {2331 let res = match syntax.kind() {2332 BIND_DESTRUCT => Bind::BindDestruct(BindDestruct { syntax }),2333 BIND_FUNCTION => Bind::BindFunction(BindFunction { syntax }),2334 _ => return None,2335 };2336 Some(res)2337 }2338 fn syntax(&self) -> &SyntaxNode {2339 match self {2340 Bind::BindDestruct(it) => &it.syntax,2341 Bind::BindFunction(it) => &it.syntax,2342 }2343 }2344}2345impl From<MemberBindStmt> for Member {2346 fn from(node: MemberBindStmt) -> Member {2347 Member::MemberBindStmt(node)2348 }2349}2350impl From<MemberAssertStmt> for Member {2351 fn from(node: MemberAssertStmt) -> Member {2352 Member::MemberAssertStmt(node)2353 }2354}2355impl From<MemberField> for Member {2356 fn from(node: MemberField) -> Member {2357 Member::MemberField(node)2358 }2359}2360impl AstNode for Member {2361 fn can_cast(kind: SyntaxKind) -> bool {2362 match kind {2363 MEMBER_BIND_STMT | MEMBER_ASSERT_STMT | MEMBER_FIELD => true,2364 _ => false,2365 }2366 }2367 fn cast(syntax: SyntaxNode) -> Option<Self> {2368 let res = match syntax.kind() {2369 MEMBER_BIND_STMT => Member::MemberBindStmt(MemberBindStmt { syntax }),2370 MEMBER_ASSERT_STMT => Member::MemberAssertStmt(MemberAssertStmt { syntax }),2371 MEMBER_FIELD => Member::MemberField(MemberField { syntax }),2372 _ => return None,2373 };2374 Some(res)2375 }2376 fn syntax(&self) -> &SyntaxNode {2377 match self {2378 Member::MemberBindStmt(it) => &it.syntax,2379 Member::MemberAssertStmt(it) => &it.syntax,2380 Member::MemberField(it) => &it.syntax,2381 }2382 }2383}2384impl From<FieldNormal> for Field {2385 fn from(node: FieldNormal) -> Field {2386 Field::FieldNormal(node)2387 }2388}2389impl From<FieldMethod> for Field {2390 fn from(node: FieldMethod) -> Field {2391 Field::FieldMethod(node)2392 }2393}2394impl AstNode for Field {2395 fn can_cast(kind: SyntaxKind) -> bool {2396 match kind {2397 FIELD_NORMAL | FIELD_METHOD => true,2398 _ => false,2399 }2400 }2401 fn cast(syntax: SyntaxNode) -> Option<Self> {2402 let res = match syntax.kind() {2403 FIELD_NORMAL => Field::FieldNormal(FieldNormal { syntax }),2404 FIELD_METHOD => Field::FieldMethod(FieldMethod { syntax }),2405 _ => return None,2406 };2407 Some(res)2408 }2409 fn syntax(&self) -> &SyntaxNode {2410 match self {2411 Field::FieldNormal(it) => &it.syntax,2412 Field::FieldMethod(it) => &it.syntax,2413 }2414 }2415}2416impl From<FieldNameFixed> for FieldName {2417 fn from(node: FieldNameFixed) -> FieldName {2418 FieldName::FieldNameFixed(node)2419 }2420}2421impl From<FieldNameDynamic> for FieldName {2422 fn from(node: FieldNameDynamic) -> FieldName {2423 FieldName::FieldNameDynamic(node)2424 }2425}2426impl AstNode for FieldName {2427 fn can_cast(kind: SyntaxKind) -> bool {2428 match kind {2429 FIELD_NAME_FIXED | FIELD_NAME_DYNAMIC => true,2430 _ => false,2431 }2432 }2433 fn cast(syntax: SyntaxNode) -> Option<Self> {2434 let res = match syntax.kind() {2435 FIELD_NAME_FIXED => FieldName::FieldNameFixed(FieldNameFixed { syntax }),2436 FIELD_NAME_DYNAMIC => FieldName::FieldNameDynamic(FieldNameDynamic { syntax }),2437 _ => return None,2438 };2439 Some(res)2440 }2441 fn syntax(&self) -> &SyntaxNode {2442 match self {2443 FieldName::FieldNameFixed(it) => &it.syntax,2444 FieldName::FieldNameDynamic(it) => &it.syntax,2445 }2446 }2447}2448impl From<DestructFull> for Destruct {2449 fn from(node: DestructFull) -> Destruct {2450 Destruct::DestructFull(node)2451 }2452}2453impl From<DestructSkip> for Destruct {2454 fn from(node: DestructSkip) -> Destruct {2455 Destruct::DestructSkip(node)2456 }2457}2458impl From<DestructArray> for Destruct {2459 fn from(node: DestructArray) -> Destruct {2460 Destruct::DestructArray(node)2461 }2462}2463impl From<DestructObject> for Destruct {2464 fn from(node: DestructObject) -> Destruct {2465 Destruct::DestructObject(node)2466 }2467}2468impl AstNode for Destruct {2469 fn can_cast(kind: SyntaxKind) -> bool {2470 match kind {2471 DESTRUCT_FULL | DESTRUCT_SKIP | DESTRUCT_ARRAY | DESTRUCT_OBJECT => true,2472 _ => false,2473 }2474 }2475 fn cast(syntax: SyntaxNode) -> Option<Self> {2476 let res = match syntax.kind() {2477 DESTRUCT_FULL => Destruct::DestructFull(DestructFull { syntax }),2478 DESTRUCT_SKIP => Destruct::DestructSkip(DestructSkip { syntax }),2479 DESTRUCT_ARRAY => Destruct::DestructArray(DestructArray { syntax }),2480 DESTRUCT_OBJECT => Destruct::DestructObject(DestructObject { syntax }),2481 _ => return None,2482 };2483 Some(res)2484 }2485 fn syntax(&self) -> &SyntaxNode {2486 match self {2487 Destruct::DestructFull(it) => &it.syntax,2488 Destruct::DestructSkip(it) => &it.syntax,2489 Destruct::DestructArray(it) => &it.syntax,2490 Destruct::DestructObject(it) => &it.syntax,2491 }2492 }2493}2494impl From<DestructArrayElement> for DestructArrayPart {2495 fn from(node: DestructArrayElement) -> DestructArrayPart {2496 DestructArrayPart::DestructArrayElement(node)2497 }2498}2499impl From<DestructRest> for DestructArrayPart {2500 fn from(node: DestructRest) -> DestructArrayPart {2501 DestructArrayPart::DestructRest(node)2502 }2503}2504impl AstNode for DestructArrayPart {2505 fn can_cast(kind: SyntaxKind) -> bool {2506 match kind {2507 DESTRUCT_ARRAY_ELEMENT | DESTRUCT_REST => true,2508 _ => false,2509 }2510 }2511 fn cast(syntax: SyntaxNode) -> Option<Self> {2512 let res = match syntax.kind() {2513 DESTRUCT_ARRAY_ELEMENT => {2514 DestructArrayPart::DestructArrayElement(DestructArrayElement { syntax })2515 }2516 DESTRUCT_REST => DestructArrayPart::DestructRest(DestructRest { syntax }),2517 _ => return None,2518 };2519 Some(res)2520 }2521 fn syntax(&self) -> &SyntaxNode {2522 match self {2523 DestructArrayPart::DestructArrayElement(it) => &it.syntax,2524 DestructArrayPart::DestructRest(it) => &it.syntax,2525 }2526 }2527}2528impl AstToken for BinaryOperator {2529 fn can_cast(kind: SyntaxKind) -> bool {2530 BinaryOperatorKind::can_cast(kind)2531 }2532 fn cast(syntax: SyntaxToken) -> Option<Self> {2533 let kind = BinaryOperatorKind::cast(syntax.kind())?;2534 Some(BinaryOperator { syntax, kind })2535 }2536 fn syntax(&self) -> &SyntaxToken {2537 &self.syntax2538 }2539}2540impl BinaryOperatorKind {2541 fn can_cast(kind: SyntaxKind) -> bool {2542 match kind {2543 OR | AND | BIT_OR | BIT_XOR | BIT_AND | EQ | NE | LT | GT | LE | GE | IN_KW | LHS2544 | RHS | PLUS | MINUS | MUL | DIV | MODULO | META_OBJECT_APPLY | ERROR_NO_OPERATOR => true,2545 _ => false,2546 }2547 }2548 pub fn cast(kind: SyntaxKind) -> Option<Self> {2549 let res = match kind {2550 OR => Self::Or,2551 AND => Self::And,2552 BIT_OR => Self::BitOr,2553 BIT_XOR => Self::BitXor,2554 BIT_AND => Self::BitAnd,2555 EQ => Self::Eq,2556 NE => Self::Ne,2557 LT => Self::Lt,2558 GT => Self::Gt,2559 LE => Self::Le,2560 GE => Self::Ge,2561 IN_KW => Self::InKw,2562 LHS => Self::Lhs,2563 RHS => Self::Rhs,2564 PLUS => Self::Plus,2565 MINUS => Self::Minus,2566 MUL => Self::Mul,2567 DIV => Self::Div,2568 MODULO => Self::Modulo,2569 META_OBJECT_APPLY => Self::MetaObjectApply,2570 ERROR_NO_OPERATOR => Self::ErrorNoOperator,2571 _ => return None,2572 };2573 Some(res)2574 }2575}2576impl BinaryOperator {2577 pub fn kind(&self) -> BinaryOperatorKind {2578 self.kind2579 }2580}2581impl std::fmt::Display for BinaryOperator {2582 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2583 std::fmt::Display::fmt(self.syntax(), f)2584 }2585}2586impl AstToken for UnaryOperator {2587 fn can_cast(kind: SyntaxKind) -> bool {2588 UnaryOperatorKind::can_cast(kind)2589 }2590 fn cast(syntax: SyntaxToken) -> Option<Self> {2591 let kind = UnaryOperatorKind::cast(syntax.kind())?;2592 Some(UnaryOperator { syntax, kind })2593 }2594 fn syntax(&self) -> &SyntaxToken {2595 &self.syntax2596 }2597}2598impl UnaryOperatorKind {2599 fn can_cast(kind: SyntaxKind) -> bool {2600 match kind {2601 MINUS | NOT | BIT_NOT => true,2602 _ => false,2603 }2604 }2605 pub fn cast(kind: SyntaxKind) -> Option<Self> {2606 let res = match kind {2607 MINUS => Self::Minus,2608 NOT => Self::Not,2609 BIT_NOT => Self::BitNot,2610 _ => return None,2611 };2612 Some(res)2613 }2614}2615impl UnaryOperator {2616 pub fn kind(&self) -> UnaryOperatorKind {2617 self.kind2618 }2619}2620impl std::fmt::Display for UnaryOperator {2621 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2622 std::fmt::Display::fmt(self.syntax(), f)2623 }2624}2625impl AstToken for Literal {2626 fn can_cast(kind: SyntaxKind) -> bool {2627 LiteralKind::can_cast(kind)2628 }2629 fn cast(syntax: SyntaxToken) -> Option<Self> {2630 let kind = LiteralKind::cast(syntax.kind())?;2631 Some(Literal { syntax, kind })2632 }2633 fn syntax(&self) -> &SyntaxToken {2634 &self.syntax2635 }2636}2637impl LiteralKind {2638 fn can_cast(kind: SyntaxKind) -> bool {2639 match kind {2640 NULL_KW | TRUE_KW | FALSE_KW | SELF_KW | DOLLAR | SUPER_KW => true,2641 _ => false,2642 }2643 }2644 pub fn cast(kind: SyntaxKind) -> Option<Self> {2645 let res = match kind {2646 NULL_KW => Self::NullKw,2647 TRUE_KW => Self::TrueKw,2648 FALSE_KW => Self::FalseKw,2649 SELF_KW => Self::SelfKw,2650 DOLLAR => Self::Dollar,2651 SUPER_KW => Self::SuperKw,2652 _ => return None,2653 };2654 Some(res)2655 }2656}2657impl Literal {2658 pub fn kind(&self) -> LiteralKind {2659 self.kind2660 }2661}2662impl std::fmt::Display for Literal {2663 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2664 std::fmt::Display::fmt(self.syntax(), f)2665 }2666}2667impl AstToken for Text {2668 fn can_cast(kind: SyntaxKind) -> bool {2669 TextKind::can_cast(kind)2670 }2671 fn cast(syntax: SyntaxToken) -> Option<Self> {2672 let kind = TextKind::cast(syntax.kind())?;2673 Some(Text { syntax, kind })2674 }2675 fn syntax(&self) -> &SyntaxToken {2676 &self.syntax2677 }2678}2679impl TextKind {2680 fn can_cast(kind: SyntaxKind) -> bool {2681 match kind {2682 STRING_DOUBLE2683 | ERROR_STRING_DOUBLE_UNTERMINATED2684 | STRING_SINGLE2685 | ERROR_STRING_SINGLE_UNTERMINATED2686 | STRING_DOUBLE_VERBATIM2687 | ERROR_STRING_DOUBLE_VERBATIM_UNTERMINATED2688 | STRING_SINGLE_VERBATIM2689 | ERROR_STRING_SINGLE_VERBATIM_UNTERMINATED2690 | ERROR_STRING_VERBATIM_MISSING_QUOTES2691 | STRING_BLOCK2692 | ERROR_STRING_BLOCK_UNEXPECTED_END2693 | ERROR_STRING_BLOCK_MISSING_NEW_LINE2694 | ERROR_STRING_BLOCK_MISSING_TERMINATION2695 | ERROR_STRING_BLOCK_MISSING_INDENT => true,2696 _ => false,2697 }2698 }2699 pub fn cast(kind: SyntaxKind) -> Option<Self> {2700 let res = match kind {2701 STRING_DOUBLE => Self::StringDouble,2702 ERROR_STRING_DOUBLE_UNTERMINATED => Self::ErrorStringDoubleUnterminated,2703 STRING_SINGLE => Self::StringSingle,2704 ERROR_STRING_SINGLE_UNTERMINATED => Self::ErrorStringSingleUnterminated,2705 STRING_DOUBLE_VERBATIM => Self::StringDoubleVerbatim,2706 ERROR_STRING_DOUBLE_VERBATIM_UNTERMINATED => {2707 Self::ErrorStringDoubleVerbatimUnterminated2708 }2709 STRING_SINGLE_VERBATIM => Self::StringSingleVerbatim,2710 ERROR_STRING_SINGLE_VERBATIM_UNTERMINATED => {2711 Self::ErrorStringSingleVerbatimUnterminated2712 }2713 ERROR_STRING_VERBATIM_MISSING_QUOTES => Self::ErrorStringVerbatimMissingQuotes,2714 STRING_BLOCK => Self::StringBlock,2715 ERROR_STRING_BLOCK_UNEXPECTED_END => Self::ErrorStringBlockUnexpectedEnd,2716 ERROR_STRING_BLOCK_MISSING_NEW_LINE => Self::ErrorStringBlockMissingNewLine,2717 ERROR_STRING_BLOCK_MISSING_TERMINATION => Self::ErrorStringBlockMissingTermination,2718 ERROR_STRING_BLOCK_MISSING_INDENT => Self::ErrorStringBlockMissingIndent,2719 _ => return None,2720 };2721 Some(res)2722 }2723}2724impl Text {2725 pub fn kind(&self) -> TextKind {2726 self.kind2727 }2728}2729impl std::fmt::Display for Text {2730 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2731 std::fmt::Display::fmt(self.syntax(), f)2732 }2733}2734impl AstToken for Number {2735 fn can_cast(kind: SyntaxKind) -> bool {2736 NumberKind::can_cast(kind)2737 }2738 fn cast(syntax: SyntaxToken) -> Option<Self> {2739 let kind = NumberKind::cast(syntax.kind())?;2740 Some(Number { syntax, kind })2741 }2742 fn syntax(&self) -> &SyntaxToken {2743 &self.syntax2744 }2745}2746impl NumberKind {2747 fn can_cast(kind: SyntaxKind) -> bool {2748 match kind {2749 FLOAT2750 | ERROR_FLOAT_JUNK_AFTER_POINT2751 | ERROR_FLOAT_JUNK_AFTER_EXPONENT2752 | ERROR_FLOAT_JUNK_AFTER_EXPONENT_SIGN => true,2753 _ => false,2754 }2755 }2756 pub fn cast(kind: SyntaxKind) -> Option<Self> {2757 let res = match kind {2758 FLOAT => Self::Float,2759 ERROR_FLOAT_JUNK_AFTER_POINT => Self::ErrorFloatJunkAfterPoint,2760 ERROR_FLOAT_JUNK_AFTER_EXPONENT => Self::ErrorFloatJunkAfterExponent,2761 ERROR_FLOAT_JUNK_AFTER_EXPONENT_SIGN => Self::ErrorFloatJunkAfterExponentSign,2762 _ => return None,2763 };2764 Some(res)2765 }2766}2767impl Number {2768 pub fn kind(&self) -> NumberKind {2769 self.kind2770 }2771}2772impl std::fmt::Display for Number {2773 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2774 std::fmt::Display::fmt(self.syntax(), f)2775 }2776}2777impl AstToken for ImportKind {2778 fn can_cast(kind: SyntaxKind) -> bool {2779 ImportKindKind::can_cast(kind)2780 }2781 fn cast(syntax: SyntaxToken) -> Option<Self> {2782 let kind = ImportKindKind::cast(syntax.kind())?;2783 Some(ImportKind { syntax, kind })2784 }2785 fn syntax(&self) -> &SyntaxToken {2786 &self.syntax2787 }2788}2789impl ImportKindKind {2790 fn can_cast(kind: SyntaxKind) -> bool {2791 match kind {2792 IMPORTSTR_KW | IMPORTBIN_KW | IMPORT_KW => true,2793 _ => false,2794 }2795 }2796 pub fn cast(kind: SyntaxKind) -> Option<Self> {2797 let res = match kind {2798 IMPORTSTR_KW => Self::ImportstrKw,2799 IMPORTBIN_KW => Self::ImportbinKw,2800 IMPORT_KW => Self::ImportKw,2801 _ => return None,2802 };2803 Some(res)2804 }2805}2806impl ImportKind {2807 pub fn kind(&self) -> ImportKindKind {2808 self.kind2809 }2810}2811impl std::fmt::Display for ImportKind {2812 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2813 std::fmt::Display::fmt(self.syntax(), f)2814 }2815}2816impl AstToken for Visibility {2817 fn can_cast(kind: SyntaxKind) -> bool {2818 VisibilityKind::can_cast(kind)2819 }2820 fn cast(syntax: SyntaxToken) -> Option<Self> {2821 let kind = VisibilityKind::cast(syntax.kind())?;2822 Some(Visibility { syntax, kind })2823 }2824 fn syntax(&self) -> &SyntaxToken {2825 &self.syntax2826 }2827}2828impl VisibilityKind {2829 fn can_cast(kind: SyntaxKind) -> bool {2830 match kind {2831 COLONCOLONCOLON | COLONCOLON | COLON => true,2832 _ => false,2833 }2834 }2835 pub fn cast(kind: SyntaxKind) -> Option<Self> {2836 let res = match kind {2837 COLONCOLONCOLON => Self::Coloncoloncolon,2838 COLONCOLON => Self::Coloncolon,2839 COLON => Self::Colon,2840 _ => return None,2841 };2842 Some(res)2843 }2844}2845impl Visibility {2846 pub fn kind(&self) -> VisibilityKind {2847 self.kind2848 }2849}2850impl std::fmt::Display for Visibility {2851 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2852 std::fmt::Display::fmt(self.syntax(), f)2853 }2854}2855impl AstToken for Trivia {2856 fn can_cast(kind: SyntaxKind) -> bool {2857 TriviaKind::can_cast(kind)2858 }2859 fn cast(syntax: SyntaxToken) -> Option<Self> {2860 let kind = TriviaKind::cast(syntax.kind())?;2861 Some(Trivia { syntax, kind })2862 }2863 fn syntax(&self) -> &SyntaxToken {2864 &self.syntax2865 }2866}2867impl TriviaKind {2868 fn can_cast(kind: SyntaxKind) -> bool {2869 match kind {2870 WHITESPACE2871 | MULTI_LINE_COMMENT2872 | ERROR_COMMENT_TOO_SHORT2873 | ERROR_COMMENT_UNTERMINATED2874 | SINGLE_LINE_HASH_COMMENT2875 | SINGLE_LINE_SLASH_COMMENT => true,2876 _ => false,2877 }2878 }2879 pub fn cast(kind: SyntaxKind) -> Option<Self> {2880 let res = match kind {2881 WHITESPACE => Self::Whitespace,2882 MULTI_LINE_COMMENT => Self::MultiLineComment,2883 ERROR_COMMENT_TOO_SHORT => Self::ErrorCommentTooShort,2884 ERROR_COMMENT_UNTERMINATED => Self::ErrorCommentUnterminated,2885 SINGLE_LINE_HASH_COMMENT => Self::SingleLineHashComment,2886 SINGLE_LINE_SLASH_COMMENT => Self::SingleLineSlashComment,2887 _ => return None,2888 };2889 Some(res)2890 }2891}2892impl Trivia {2893 pub fn kind(&self) -> TriviaKind {2894 self.kind2895 }2896}2897impl std::fmt::Display for Trivia {2898 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2899 std::fmt::Display::fmt(self.syntax(), f)2900 }2901}2902impl AstToken for ParsingError {2903 fn can_cast(kind: SyntaxKind) -> bool {2904 ParsingErrorKind::can_cast(kind)2905 }2906 fn cast(syntax: SyntaxToken) -> Option<Self> {2907 let kind = ParsingErrorKind::cast(syntax.kind())?;2908 Some(ParsingError { syntax, kind })2909 }2910 fn syntax(&self) -> &SyntaxToken {2911 &self.syntax2912 }2913}2914impl ParsingErrorKind {2915 fn can_cast(kind: SyntaxKind) -> bool {2916 match kind {2917 ERROR_MISSING_TOKEN | ERROR_UNEXPECTED_TOKEN => true,2918 _ => false,2919 }2920 }2921 pub fn cast(kind: SyntaxKind) -> Option<Self> {2922 let res = match kind {2923 ERROR_MISSING_TOKEN => Self::ErrorMissingToken,2924 ERROR_UNEXPECTED_TOKEN => Self::ErrorUnexpectedToken,2925 _ => return None,2926 };2927 Some(res)2928 }2929}2930impl ParsingError {2931 pub fn kind(&self) -> ParsingErrorKind {2932 self.kind2933 }2934}2935impl std::fmt::Display for ParsingError {2936 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2937 std::fmt::Display::fmt(self.syntax(), f)2938 }2939}2940impl std::fmt::Display for Expr {2941 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2942 std::fmt::Display::fmt(self.syntax(), f)2943 }2944}2945impl std::fmt::Display for ObjBody {2946 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2947 std::fmt::Display::fmt(self.syntax(), f)2948 }2949}2950impl std::fmt::Display for CompSpec {2951 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2952 std::fmt::Display::fmt(self.syntax(), f)2953 }2954}2955impl std::fmt::Display for Bind {2956 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2957 std::fmt::Display::fmt(self.syntax(), f)2958 }2959}2960impl std::fmt::Display for Member {2961 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2962 std::fmt::Display::fmt(self.syntax(), f)2963 }2964}2965impl std::fmt::Display for Field {2966 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2967 std::fmt::Display::fmt(self.syntax(), f)2968 }2969}2970impl std::fmt::Display for FieldName {2971 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2972 std::fmt::Display::fmt(self.syntax(), f)2973 }2974}2975impl std::fmt::Display for Destruct {2976 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2977 std::fmt::Display::fmt(self.syntax(), f)2978 }2979}2980impl std::fmt::Display for DestructArrayPart {2981 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2982 std::fmt::Display::fmt(self.syntax(), f)2983 }2984}2985impl std::fmt::Display for SourceFile {2986 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2987 std::fmt::Display::fmt(self.syntax(), f)2988 }2989}2990impl std::fmt::Display for ExprBinary {2991 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2992 std::fmt::Display::fmt(self.syntax(), f)2993 }2994}2995impl std::fmt::Display for LhsExpr {2996 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2997 std::fmt::Display::fmt(self.syntax(), f)2998 }2999}3000impl std::fmt::Display for ExprUnary {3001 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3002 std::fmt::Display::fmt(self.syntax(), f)3003 }3004}3005impl std::fmt::Display for ExprSlice {3006 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3007 std::fmt::Display::fmt(self.syntax(), f)3008 }3009}3010impl std::fmt::Display for SliceDesc {3011 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3012 std::fmt::Display::fmt(self.syntax(), f)3013 }3014}3015impl std::fmt::Display for ExprIndex {3016 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3017 std::fmt::Display::fmt(self.syntax(), f)3018 }3019}3020impl std::fmt::Display for Name {3021 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3022 std::fmt::Display::fmt(self.syntax(), f)3023 }3024}3025impl std::fmt::Display for ExprIndexExpr {3026 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3027 std::fmt::Display::fmt(self.syntax(), f)3028 }3029}3030impl std::fmt::Display for ExprApply {3031 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3032 std::fmt::Display::fmt(self.syntax(), f)3033 }3034}3035impl std::fmt::Display for ArgsDesc {3036 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3037 std::fmt::Display::fmt(self.syntax(), f)3038 }3039}3040impl std::fmt::Display for ExprObjExtend {3041 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3042 std::fmt::Display::fmt(self.syntax(), f)3043 }3044}3045impl std::fmt::Display for ExprParened {3046 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3047 std::fmt::Display::fmt(self.syntax(), f)3048 }3049}3050impl std::fmt::Display for ExprLiteral {3051 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3052 std::fmt::Display::fmt(self.syntax(), f)3053 }3054}3055impl std::fmt::Display for ExprIntrinsicThisFile {3056 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3057 std::fmt::Display::fmt(self.syntax(), f)3058 }3059}3060impl std::fmt::Display for ExprIntrinsicId {3061 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3062 std::fmt::Display::fmt(self.syntax(), f)3063 }3064}3065impl std::fmt::Display for ExprIntrinsic {3066 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3067 std::fmt::Display::fmt(self.syntax(), f)3068 }3069}3070impl std::fmt::Display for ExprString {3071 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3072 std::fmt::Display::fmt(self.syntax(), f)3073 }3074}3075impl std::fmt::Display for ExprNumber {3076 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3077 std::fmt::Display::fmt(self.syntax(), f)3078 }3079}3080impl std::fmt::Display for ExprArray {3081 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3082 std::fmt::Display::fmt(self.syntax(), f)3083 }3084}3085impl std::fmt::Display for ExprObject {3086 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3087 std::fmt::Display::fmt(self.syntax(), f)3088 }3089}3090impl std::fmt::Display for ExprArrayComp {3091 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3092 std::fmt::Display::fmt(self.syntax(), f)3093 }3094}3095impl std::fmt::Display for ExprImport {3096 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3097 std::fmt::Display::fmt(self.syntax(), f)3098 }3099}3100impl std::fmt::Display for ExprVar {3101 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3102 std::fmt::Display::fmt(self.syntax(), f)3103 }3104}3105impl std::fmt::Display for ExprLocal {3106 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3107 std::fmt::Display::fmt(self.syntax(), f)3108 }3109}3110impl std::fmt::Display for ExprIfThenElse {3111 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3112 std::fmt::Display::fmt(self.syntax(), f)3113 }3114}3115impl std::fmt::Display for TrueExpr {3116 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3117 std::fmt::Display::fmt(self.syntax(), f)3118 }3119}3120impl std::fmt::Display for FalseExpr {3121 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3122 std::fmt::Display::fmt(self.syntax(), f)3123 }3124}3125impl std::fmt::Display for ExprFunction {3126 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3127 std::fmt::Display::fmt(self.syntax(), f)3128 }3129}3130impl std::fmt::Display for ParamsDesc {3131 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3132 std::fmt::Display::fmt(self.syntax(), f)3133 }3134}3135impl std::fmt::Display for ExprAssert {3136 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3137 std::fmt::Display::fmt(self.syntax(), f)3138 }3139}3140impl std::fmt::Display for Assertion {3141 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3142 std::fmt::Display::fmt(self.syntax(), f)3143 }3144}3145impl std::fmt::Display for ExprError {3146 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3147 std::fmt::Display::fmt(self.syntax(), f)3148 }3149}3150impl std::fmt::Display for SliceDescEnd {3151 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3152 std::fmt::Display::fmt(self.syntax(), f)3153 }3154}3155impl std::fmt::Display for SliceDescStep {3156 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3157 std::fmt::Display::fmt(self.syntax(), f)3158 }3159}3160impl std::fmt::Display for Arg {3161 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3162 std::fmt::Display::fmt(self.syntax(), f)3163 }3164}3165impl std::fmt::Display for ObjBodyComp {3166 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3167 std::fmt::Display::fmt(self.syntax(), f)3168 }3169}3170impl std::fmt::Display for ObjLocalPostComma {3171 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3172 std::fmt::Display::fmt(self.syntax(), f)3173 }3174}3175impl std::fmt::Display for ObjLocalPreComma {3176 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3177 std::fmt::Display::fmt(self.syntax(), f)3178 }3179}3180impl std::fmt::Display for ObjBodyMemberList {3181 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3182 std::fmt::Display::fmt(self.syntax(), f)3183 }3184}3185impl std::fmt::Display for ObjLocal {3186 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3187 std::fmt::Display::fmt(self.syntax(), f)3188 }3189}3190impl std::fmt::Display for MemberBindStmt {3191 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3192 std::fmt::Display::fmt(self.syntax(), f)3193 }3194}3195impl std::fmt::Display for MemberAssertStmt {3196 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3197 std::fmt::Display::fmt(self.syntax(), f)3198 }3199}3200impl std::fmt::Display for MemberField {3201 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3202 std::fmt::Display::fmt(self.syntax(), f)3203 }3204}3205impl std::fmt::Display for FieldNormal {3206 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3207 std::fmt::Display::fmt(self.syntax(), f)3208 }3209}3210impl std::fmt::Display for FieldMethod {3211 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3212 std::fmt::Display::fmt(self.syntax(), f)3213 }3214}3215impl std::fmt::Display for FieldNameFixed {3216 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3217 std::fmt::Display::fmt(self.syntax(), f)3218 }3219}3220impl std::fmt::Display for FieldNameDynamic {3221 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3222 std::fmt::Display::fmt(self.syntax(), f)3223 }3224}3225impl std::fmt::Display for ForSpec {3226 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3227 std::fmt::Display::fmt(self.syntax(), f)3228 }3229}3230impl std::fmt::Display for IfSpec {3231 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3232 std::fmt::Display::fmt(self.syntax(), f)3233 }3234}3235impl std::fmt::Display for BindDestruct {3236 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3237 std::fmt::Display::fmt(self.syntax(), f)3238 }3239}3240impl std::fmt::Display for BindFunction {3241 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3242 std::fmt::Display::fmt(self.syntax(), f)3243 }3244}3245impl std::fmt::Display for Param {3246 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3247 std::fmt::Display::fmt(self.syntax(), f)3248 }3249}3250impl std::fmt::Display for DestructFull {3251 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3252 std::fmt::Display::fmt(self.syntax(), f)3253 }3254}3255impl std::fmt::Display for DestructSkip {3256 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3257 std::fmt::Display::fmt(self.syntax(), f)3258 }3259}3260impl std::fmt::Display for DestructArray {3261 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3262 std::fmt::Display::fmt(self.syntax(), f)3263 }3264}3265impl std::fmt::Display for DestructObject {3266 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3267 std::fmt::Display::fmt(self.syntax(), f)3268 }3269}3270impl std::fmt::Display for DestructObjectField {3271 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3272 std::fmt::Display::fmt(self.syntax(), f)3273 }3274}3275impl std::fmt::Display for DestructRest {3276 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3277 std::fmt::Display::fmt(self.syntax(), f)3278 }3279}3280impl std::fmt::Display for DestructArrayElement {3281 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3282 std::fmt::Display::fmt(self.syntax(), f)3283 }3284}