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 string(&self) -> Option<String> {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 l_brace_token(&self) -> Option<SyntaxToken> {295 support::token(&self.syntax, T!['{'])296 }297 pub fn obj_body(&self) -> Option<ObjBody> {298 support::child(&self.syntax)299 }300 pub fn r_brace_token(&self) -> Option<SyntaxToken> {301 support::token(&self.syntax, T!['}'])302 }303}304305#[derive(Debug, Clone, PartialEq, Eq, Hash)]306pub struct ExprArrayComp {307 pub(crate) syntax: SyntaxNode,308}309impl ExprArrayComp {310 pub fn l_brack_token(&self) -> Option<SyntaxToken> {311 support::token(&self.syntax, T!['['])312 }313 pub fn expr(&self) -> Option<Expr> {314 support::child(&self.syntax)315 }316 pub fn comma_token(&self) -> Option<SyntaxToken> {317 support::token(&self.syntax, T![,])318 }319 pub fn comp_specs(&self) -> AstChildren<CompSpec> {320 support::children(&self.syntax)321 }322 pub fn r_brack_token(&self) -> Option<SyntaxToken> {323 support::token(&self.syntax, T![']'])324 }325}326327#[derive(Debug, Clone, PartialEq, Eq, Hash)]328pub struct ExprImport {329 pub(crate) syntax: SyntaxNode,330}331impl ExprImport {332 pub fn import_kind(&self) -> Option<ImportKind> {333 support::token_child(&self.syntax)334 }335 pub fn string(&self) -> Option<String> {336 support::token_child(&self.syntax)337 }338}339340#[derive(Debug, Clone, PartialEq, Eq, Hash)]341pub struct ExprVar {342 pub(crate) syntax: SyntaxNode,343}344impl ExprVar {345 pub fn name(&self) -> Option<Name> {346 support::child(&self.syntax)347 }348}349350#[derive(Debug, Clone, PartialEq, Eq, Hash)]351pub struct ExprLocal {352 pub(crate) syntax: SyntaxNode,353}354impl ExprLocal {355 pub fn local_kw_token(&self) -> Option<SyntaxToken> {356 support::token(&self.syntax, T![local])357 }358 pub fn binds(&self) -> AstChildren<Bind> {359 support::children(&self.syntax)360 }361 pub fn semi_token(&self) -> Option<SyntaxToken> {362 support::token(&self.syntax, T![;])363 }364 pub fn expr(&self) -> Option<Expr> {365 support::child(&self.syntax)366 }367}368369#[derive(Debug, Clone, PartialEq, Eq, Hash)]370pub struct ExprIfThenElse {371 pub(crate) syntax: SyntaxNode,372}373impl ExprIfThenElse {374 pub fn if_kw_token(&self) -> Option<SyntaxToken> {375 support::token(&self.syntax, T![if])376 }377 pub fn cond(&self) -> Option<Expr> {378 support::child(&self.syntax)379 }380 pub fn then_kw_token(&self) -> Option<SyntaxToken> {381 support::token(&self.syntax, T![then])382 }383 pub fn then(&self) -> Option<TrueExpr> {384 support::child(&self.syntax)385 }386 pub fn else_kw_token(&self) -> Option<SyntaxToken> {387 support::token(&self.syntax, T![else])388 }389 pub fn else_(&self) -> Option<FalseExpr> {390 support::child(&self.syntax)391 }392}393394#[derive(Debug, Clone, PartialEq, Eq, Hash)]395pub struct TrueExpr {396 pub(crate) syntax: SyntaxNode,397}398impl TrueExpr {399 pub fn expr(&self) -> Option<Expr> {400 support::child(&self.syntax)401 }402}403404#[derive(Debug, Clone, PartialEq, Eq, Hash)]405pub struct FalseExpr {406 pub(crate) syntax: SyntaxNode,407}408impl FalseExpr {409 pub fn expr(&self) -> Option<Expr> {410 support::child(&self.syntax)411 }412}413414#[derive(Debug, Clone, PartialEq, Eq, Hash)]415pub struct ExprFunction {416 pub(crate) syntax: SyntaxNode,417}418impl ExprFunction {419 pub fn function_kw_token(&self) -> Option<SyntaxToken> {420 support::token(&self.syntax, T![function])421 }422 pub fn l_paren_token(&self) -> Option<SyntaxToken> {423 support::token(&self.syntax, T!['('])424 }425 pub fn params_desc(&self) -> Option<ParamsDesc> {426 support::child(&self.syntax)427 }428 pub fn r_paren_token(&self) -> Option<SyntaxToken> {429 support::token(&self.syntax, T![')'])430 }431 pub fn expr(&self) -> Option<Expr> {432 support::child(&self.syntax)433 }434}435436#[derive(Debug, Clone, PartialEq, Eq, Hash)]437pub struct ParamsDesc {438 pub(crate) syntax: SyntaxNode,439}440impl ParamsDesc {441 pub fn l_paren_token(&self) -> Option<SyntaxToken> {442 support::token(&self.syntax, T!['('])443 }444 pub fn params(&self) -> AstChildren<Param> {445 support::children(&self.syntax)446 }447 pub fn r_paren_token(&self) -> Option<SyntaxToken> {448 support::token(&self.syntax, T![')'])449 }450}451452#[derive(Debug, Clone, PartialEq, Eq, Hash)]453pub struct ExprAssert {454 pub(crate) syntax: SyntaxNode,455}456impl ExprAssert {457 pub fn assertion(&self) -> Option<Assertion> {458 support::child(&self.syntax)459 }460 pub fn semi_token(&self) -> Option<SyntaxToken> {461 support::token(&self.syntax, T![;])462 }463 pub fn expr(&self) -> Option<Expr> {464 support::child(&self.syntax)465 }466}467468#[derive(Debug, Clone, PartialEq, Eq, Hash)]469pub struct Assertion {470 pub(crate) syntax: SyntaxNode,471}472impl Assertion {473 pub fn assert_kw_token(&self) -> Option<SyntaxToken> {474 support::token(&self.syntax, T![assert])475 }476 pub fn condition(&self) -> Option<LhsExpr> {477 support::child(&self.syntax)478 }479 pub fn colon_token(&self) -> Option<SyntaxToken> {480 support::token(&self.syntax, T![:])481 }482 pub fn message(&self) -> Option<Expr> {483 support::child(&self.syntax)484 }485}486487#[derive(Debug, Clone, PartialEq, Eq, Hash)]488pub struct ExprError {489 pub(crate) syntax: SyntaxNode,490}491impl ExprError {492 pub fn error_kw_token(&self) -> Option<SyntaxToken> {493 support::token(&self.syntax, T![error])494 }495 pub fn expr(&self) -> Option<Expr> {496 support::child(&self.syntax)497 }498}499500#[derive(Debug, Clone, PartialEq, Eq, Hash)]501pub struct SliceDescEnd {502 pub(crate) syntax: SyntaxNode,503}504impl SliceDescEnd {505 pub fn expr(&self) -> Option<Expr> {506 support::child(&self.syntax)507 }508}509510#[derive(Debug, Clone, PartialEq, Eq, Hash)]511pub struct SliceDescStep {512 pub(crate) syntax: SyntaxNode,513}514impl SliceDescStep {515 pub fn expr(&self) -> Option<Expr> {516 support::child(&self.syntax)517 }518}519520#[derive(Debug, Clone, PartialEq, Eq, Hash)]521pub struct Arg {522 pub(crate) syntax: SyntaxNode,523}524impl Arg {525 pub fn name(&self) -> Option<Name> {526 support::child(&self.syntax)527 }528 pub fn assign_token(&self) -> Option<SyntaxToken> {529 support::token(&self.syntax, T![=])530 }531 pub fn expr(&self) -> Option<Expr> {532 support::child(&self.syntax)533 }534}535536#[derive(Debug, Clone, PartialEq, Eq, Hash)]537pub struct ObjBodyComp {538 pub(crate) syntax: SyntaxNode,539}540impl ObjBodyComp {541 pub fn pre(&self) -> AstChildren<ObjLocalPostComma> {542 support::children(&self.syntax)543 }544 pub fn l_brack_token(&self) -> Option<SyntaxToken> {545 support::token(&self.syntax, T!['['])546 }547 pub fn key(&self) -> Option<LhsExpr> {548 support::child(&self.syntax)549 }550 pub fn r_brack_token(&self) -> Option<SyntaxToken> {551 support::token(&self.syntax, T![']'])552 }553 pub fn plus_token(&self) -> Option<SyntaxToken> {554 support::token(&self.syntax, T![+])555 }556 pub fn colon_token(&self) -> Option<SyntaxToken> {557 support::token(&self.syntax, T![:])558 }559 pub fn value(&self) -> Option<Expr> {560 support::child(&self.syntax)561 }562 pub fn post(&self) -> AstChildren<ObjLocalPreComma> {563 support::children(&self.syntax)564 }565 pub fn comp_specs(&self) -> AstChildren<CompSpec> {566 support::children(&self.syntax)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 members(&self) -> AstChildren<Member> {602 support::children(&self.syntax)603 }604}605606#[derive(Debug, Clone, PartialEq, Eq, Hash)]607pub struct ObjLocal {608 pub(crate) syntax: SyntaxNode,609}610impl ObjLocal {611 pub fn local_kw_token(&self) -> Option<SyntaxToken> {612 support::token(&self.syntax, T![local])613 }614 pub fn bind(&self) -> Option<Bind> {615 support::child(&self.syntax)616 }617}618619#[derive(Debug, Clone, PartialEq, Eq, Hash)]620pub struct MemberBindStmt {621 pub(crate) syntax: SyntaxNode,622}623impl MemberBindStmt {624 pub fn obj_local(&self) -> Option<ObjLocal> {625 support::child(&self.syntax)626 }627}628629#[derive(Debug, Clone, PartialEq, Eq, Hash)]630pub struct MemberAssertStmt {631 pub(crate) syntax: SyntaxNode,632}633impl MemberAssertStmt {634 pub fn assertion(&self) -> Option<Assertion> {635 support::child(&self.syntax)636 }637}638639#[derive(Debug, Clone, PartialEq, Eq, Hash)]640pub struct MemberField {641 pub(crate) syntax: SyntaxNode,642}643impl MemberField {644 pub fn field(&self) -> Option<Field> {645 support::child(&self.syntax)646 }647}648649#[derive(Debug, Clone, PartialEq, Eq, Hash)]650pub struct FieldNormal {651 pub(crate) syntax: SyntaxNode,652}653impl FieldNormal {654 pub fn field_name(&self) -> Option<FieldName> {655 support::child(&self.syntax)656 }657 pub fn plus_token(&self) -> Option<SyntaxToken> {658 support::token(&self.syntax, T![+])659 }660 pub fn visibility(&self) -> Option<Visibility> {661 support::token_child(&self.syntax)662 }663 pub fn expr(&self) -> Option<Expr> {664 support::child(&self.syntax)665 }666}667668#[derive(Debug, Clone, PartialEq, Eq, Hash)]669pub struct FieldMethod {670 pub(crate) syntax: SyntaxNode,671}672impl FieldMethod {673 pub fn field_name(&self) -> Option<FieldName> {674 support::child(&self.syntax)675 }676 pub fn params_desc(&self) -> Option<ParamsDesc> {677 support::child(&self.syntax)678 }679 pub fn visibility(&self) -> Option<Visibility> {680 support::token_child(&self.syntax)681 }682 pub fn expr(&self) -> Option<Expr> {683 support::child(&self.syntax)684 }685}686687#[derive(Debug, Clone, PartialEq, Eq, Hash)]688pub struct FieldNameFixed {689 pub(crate) syntax: SyntaxNode,690}691impl FieldNameFixed {692 pub fn id(&self) -> Option<Name> {693 support::child(&self.syntax)694 }695 pub fn string(&self) -> Option<String> {696 support::token_child(&self.syntax)697 }698}699700#[derive(Debug, Clone, PartialEq, Eq, Hash)]701pub struct FieldNameDynamic {702 pub(crate) syntax: SyntaxNode,703}704impl FieldNameDynamic {705 pub fn l_brack_token(&self) -> Option<SyntaxToken> {706 support::token(&self.syntax, T!['['])707 }708 pub fn expr(&self) -> Option<Expr> {709 support::child(&self.syntax)710 }711 pub fn r_brack_token(&self) -> Option<SyntaxToken> {712 support::token(&self.syntax, T![']'])713 }714}715716#[derive(Debug, Clone, PartialEq, Eq, Hash)]717pub struct ForSpec {718 pub(crate) syntax: SyntaxNode,719}720impl ForSpec {721 pub fn for_kw_token(&self) -> Option<SyntaxToken> {722 support::token(&self.syntax, T![for])723 }724 pub fn bind(&self) -> Option<Name> {725 support::child(&self.syntax)726 }727 pub fn in_kw_token(&self) -> Option<SyntaxToken> {728 support::token(&self.syntax, T![in])729 }730 pub fn expr(&self) -> Option<Expr> {731 support::child(&self.syntax)732 }733}734735#[derive(Debug, Clone, PartialEq, Eq, Hash)]736pub struct IfSpec {737 pub(crate) syntax: SyntaxNode,738}739impl IfSpec {740 pub fn if_kw_token(&self) -> Option<SyntaxToken> {741 support::token(&self.syntax, T![if])742 }743 pub fn expr(&self) -> Option<Expr> {744 support::child(&self.syntax)745 }746}747748#[derive(Debug, Clone, PartialEq, Eq, Hash)]749pub struct BindDestruct {750 pub(crate) syntax: SyntaxNode,751}752impl BindDestruct {753 pub fn into(&self) -> Option<Destruct> {754 support::child(&self.syntax)755 }756 pub fn assign_token(&self) -> Option<SyntaxToken> {757 support::token(&self.syntax, T![=])758 }759 pub fn value(&self) -> Option<Expr> {760 support::child(&self.syntax)761 }762}763764#[derive(Debug, Clone, PartialEq, Eq, Hash)]765pub struct BindFunction {766 pub(crate) syntax: SyntaxNode,767}768impl BindFunction {769 pub fn name(&self) -> Option<Name> {770 support::child(&self.syntax)771 }772 pub fn params(&self) -> Option<ParamsDesc> {773 support::child(&self.syntax)774 }775 pub fn assign_token(&self) -> Option<SyntaxToken> {776 support::token(&self.syntax, T![=])777 }778 pub fn value(&self) -> Option<Expr> {779 support::child(&self.syntax)780 }781}782783#[derive(Debug, Clone, PartialEq, Eq, Hash)]784pub struct Param {785 pub(crate) syntax: SyntaxNode,786}787impl Param {788 pub fn destruct(&self) -> Option<Destruct> {789 support::child(&self.syntax)790 }791 pub fn assign_token(&self) -> Option<SyntaxToken> {792 support::token(&self.syntax, T![=])793 }794 pub fn expr(&self) -> Option<Expr> {795 support::child(&self.syntax)796 }797}798799#[derive(Debug, Clone, PartialEq, Eq, Hash)]800pub struct DestructFull {801 pub(crate) syntax: SyntaxNode,802}803impl DestructFull {804 pub fn name(&self) -> Option<Name> {805 support::child(&self.syntax)806 }807}808809#[derive(Debug, Clone, PartialEq, Eq, Hash)]810pub struct DestructSkip {811 pub(crate) syntax: SyntaxNode,812}813impl DestructSkip {814 pub fn question_mark_token(&self) -> Option<SyntaxToken> {815 support::token(&self.syntax, T![?])816 }817}818819#[derive(Debug, Clone, PartialEq, Eq, Hash)]820pub struct DestructArray {821 pub(crate) syntax: SyntaxNode,822}823impl DestructArray {824 pub fn l_brack_token(&self) -> Option<SyntaxToken> {825 support::token(&self.syntax, T!['['])826 }827 pub fn destruct_array_parts(&self) -> AstChildren<DestructArrayPart> {828 support::children(&self.syntax)829 }830 pub fn r_brack_token(&self) -> Option<SyntaxToken> {831 support::token(&self.syntax, T![']'])832 }833}834835#[derive(Debug, Clone, PartialEq, Eq, Hash)]836pub struct DestructObject {837 pub(crate) syntax: SyntaxNode,838}839impl DestructObject {840 pub fn l_brace_token(&self) -> Option<SyntaxToken> {841 support::token(&self.syntax, T!['{'])842 }843 pub fn destruct_object_fields(&self) -> AstChildren<DestructObjectField> {844 support::children(&self.syntax)845 }846 pub fn destruct_rest(&self) -> Option<DestructRest> {847 support::child(&self.syntax)848 }849 pub fn comma_token(&self) -> Option<SyntaxToken> {850 support::token(&self.syntax, T![,])851 }852 pub fn r_brace_token(&self) -> Option<SyntaxToken> {853 support::token(&self.syntax, T!['}'])854 }855}856857#[derive(Debug, Clone, PartialEq, Eq, Hash)]858pub struct DestructObjectField {859 pub(crate) syntax: SyntaxNode,860}861impl DestructObjectField {862 pub fn field(&self) -> Option<Name> {863 support::child(&self.syntax)864 }865 pub fn colon_token(&self) -> Option<SyntaxToken> {866 support::token(&self.syntax, T![:])867 }868 pub fn destruct(&self) -> Option<Destruct> {869 support::child(&self.syntax)870 }871 pub fn assign_token(&self) -> Option<SyntaxToken> {872 support::token(&self.syntax, T![=])873 }874 pub fn expr(&self) -> Option<Expr> {875 support::child(&self.syntax)876 }877}878879#[derive(Debug, Clone, PartialEq, Eq, Hash)]880pub struct DestructRest {881 pub(crate) syntax: SyntaxNode,882}883impl DestructRest {884 pub fn dotdotdot_token(&self) -> Option<SyntaxToken> {885 support::token(&self.syntax, T![...])886 }887 pub fn into(&self) -> Option<Name> {888 support::child(&self.syntax)889 }890}891892#[derive(Debug, Clone, PartialEq, Eq, Hash)]893pub struct DestructArrayElement {894 pub(crate) syntax: SyntaxNode,895}896impl DestructArrayElement {897 pub fn destruct(&self) -> Option<Destruct> {898 support::child(&self.syntax)899 }900}901902#[derive(Debug, Clone, PartialEq, Eq, Hash)]903pub enum Expr {904 ExprBinary(ExprBinary),905 ExprUnary(ExprUnary),906 ExprSlice(ExprSlice),907 ExprIndex(ExprIndex),908 ExprIndexExpr(ExprIndexExpr),909 ExprApply(ExprApply),910 ExprObjExtend(ExprObjExtend),911 ExprParened(ExprParened),912 ExprIntrinsicThisFile(ExprIntrinsicThisFile),913 ExprIntrinsicId(ExprIntrinsicId),914 ExprIntrinsic(ExprIntrinsic),915 ExprString(ExprString),916 ExprNumber(ExprNumber),917 ExprLiteral(ExprLiteral),918 ExprArray(ExprArray),919 ExprObject(ExprObject),920 ExprArrayComp(ExprArrayComp),921 ExprImport(ExprImport),922 ExprVar(ExprVar),923 ExprLocal(ExprLocal),924 ExprIfThenElse(ExprIfThenElse),925 ExprFunction(ExprFunction),926 ExprAssert(ExprAssert),927 ExprError(ExprError),928}929930#[derive(Debug, Clone, PartialEq, Eq, Hash)]931pub enum ObjBody {932 ObjBodyComp(ObjBodyComp),933 ObjBodyMemberList(ObjBodyMemberList),934}935936#[derive(Debug, Clone, PartialEq, Eq, Hash)]937pub enum CompSpec {938 ForSpec(ForSpec),939 IfSpec(IfSpec),940}941942#[derive(Debug, Clone, PartialEq, Eq, Hash)]943pub enum Bind {944 BindDestruct(BindDestruct),945 BindFunction(BindFunction),946}947948#[derive(Debug, Clone, PartialEq, Eq, Hash)]949pub enum Member {950 MemberBindStmt(MemberBindStmt),951 MemberAssertStmt(MemberAssertStmt),952 MemberField(MemberField),953}954955#[derive(Debug, Clone, PartialEq, Eq, Hash)]956pub enum Field {957 FieldNormal(FieldNormal),958 FieldMethod(FieldMethod),959}960961#[derive(Debug, Clone, PartialEq, Eq, Hash)]962pub enum FieldName {963 FieldNameFixed(FieldNameFixed),964 FieldNameDynamic(FieldNameDynamic),965}966967#[derive(Debug, Clone, PartialEq, Eq, Hash)]968pub enum Destruct {969 DestructFull(DestructFull),970 DestructSkip(DestructSkip),971 DestructArray(DestructArray),972 DestructObject(DestructObject),973}974975#[derive(Debug, Clone, PartialEq, Eq, Hash)]976pub enum DestructArrayPart {977 DestructArrayElement(DestructArrayElement),978 DestructRest(DestructRest),979}980981#[derive(Debug, Clone, PartialEq, Eq, Hash)]982pub struct BinaryOperator {983 syntax: SyntaxToken,984 kind: BinaryOperatorKind,985}986987#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]988pub enum BinaryOperatorKind {989 Or,990 And,991 BitOr,992 BitXor,993 BitAnd,994 Eq,995 Ne,996 Lt,997 Gt,998 Le,999 Ge,1000 InKw,1001 Lhs,1002 Rhs,1003 Plus,1004 Minus,1005 Mul,1006 Div,1007 Modulo,1008 ErrorNoOperator,1009}10101011#[derive(Debug, Clone, PartialEq, Eq, Hash)]1012pub struct UnaryOperator {1013 syntax: SyntaxToken,1014 kind: UnaryOperatorKind,1015}10161017#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]1018pub enum UnaryOperatorKind {1019 Minus,1020 Not,1021 BitNot,1022}10231024#[derive(Debug, Clone, PartialEq, Eq, Hash)]1025pub struct Literal {1026 syntax: SyntaxToken,1027 kind: LiteralKind,1028}10291030#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]1031pub enum LiteralKind {1032 NullKw,1033 TrueKw,1034 FalseKw,1035 SelfKw,1036 Dollar,1037 SuperKw,1038}10391040#[derive(Debug, Clone, PartialEq, Eq, Hash)]1041pub struct String {1042 syntax: SyntaxToken,1043 kind: StringKind,1044}10451046#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]1047pub enum StringKind {1048 StringDouble,1049 StringSingle,1050 StringDoubleVerbatim,1051 StringSingleVerbatim,1052 StringBlock,1053}10541055#[derive(Debug, Clone, PartialEq, Eq, Hash)]1056pub struct Number {1057 syntax: SyntaxToken,1058 kind: NumberKind,1059}10601061#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]1062pub enum NumberKind {1063 Float,1064 MetaForceEnum,1065}10661067#[derive(Debug, Clone, PartialEq, Eq, Hash)]1068pub struct ImportKind {1069 syntax: SyntaxToken,1070 kind: ImportKindKind,1071}10721073#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]1074pub enum ImportKindKind {1075 ImportstrKw,1076 ImportbinKw,1077 ImportKw,1078}10791080#[derive(Debug, Clone, PartialEq, Eq, Hash)]1081pub struct Visibility {1082 syntax: SyntaxToken,1083 kind: VisibilityKind,1084}10851086#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]1087pub enum VisibilityKind {1088 Coloncoloncolon,1089 Coloncolon,1090 Colon,1091}1092impl AstNode for SourceFile {1093 fn can_cast(kind: SyntaxKind) -> bool {1094 kind == SOURCE_FILE1095 }1096 fn cast(syntax: SyntaxNode) -> Option<Self> {1097 if Self::can_cast(syntax.kind()) {1098 Some(Self { syntax })1099 } else {1100 None1101 }1102 }1103 fn syntax(&self) -> &SyntaxNode {1104 &self.syntax1105 }1106}1107impl AstNode for ExprBinary {1108 fn can_cast(kind: SyntaxKind) -> bool {1109 kind == EXPR_BINARY1110 }1111 fn cast(syntax: SyntaxNode) -> Option<Self> {1112 if Self::can_cast(syntax.kind()) {1113 Some(Self { syntax })1114 } else {1115 None1116 }1117 }1118 fn syntax(&self) -> &SyntaxNode {1119 &self.syntax1120 }1121}1122impl AstNode for LhsExpr {1123 fn can_cast(kind: SyntaxKind) -> bool {1124 kind == LHS_EXPR1125 }1126 fn cast(syntax: SyntaxNode) -> Option<Self> {1127 if Self::can_cast(syntax.kind()) {1128 Some(Self { syntax })1129 } else {1130 None1131 }1132 }1133 fn syntax(&self) -> &SyntaxNode {1134 &self.syntax1135 }1136}1137impl AstNode for ExprUnary {1138 fn can_cast(kind: SyntaxKind) -> bool {1139 kind == EXPR_UNARY1140 }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 {1149 &self.syntax1150 }1151}1152impl AstNode for ExprSlice {1153 fn can_cast(kind: SyntaxKind) -> bool {1154 kind == EXPR_SLICE1155 }1156 fn cast(syntax: SyntaxNode) -> Option<Self> {1157 if Self::can_cast(syntax.kind()) {1158 Some(Self { syntax })1159 } else {1160 None1161 }1162 }1163 fn syntax(&self) -> &SyntaxNode {1164 &self.syntax1165 }1166}1167impl AstNode for SliceDesc {1168 fn can_cast(kind: SyntaxKind) -> bool {1169 kind == SLICE_DESC1170 }1171 fn cast(syntax: SyntaxNode) -> Option<Self> {1172 if Self::can_cast(syntax.kind()) {1173 Some(Self { syntax })1174 } else {1175 None1176 }1177 }1178 fn syntax(&self) -> &SyntaxNode {1179 &self.syntax1180 }1181}1182impl AstNode for ExprIndex {1183 fn can_cast(kind: SyntaxKind) -> bool {1184 kind == EXPR_INDEX1185 }1186 fn cast(syntax: SyntaxNode) -> Option<Self> {1187 if Self::can_cast(syntax.kind()) {1188 Some(Self { syntax })1189 } else {1190 None1191 }1192 }1193 fn syntax(&self) -> &SyntaxNode {1194 &self.syntax1195 }1196}1197impl AstNode for Name {1198 fn can_cast(kind: SyntaxKind) -> bool {1199 kind == NAME1200 }1201 fn cast(syntax: SyntaxNode) -> Option<Self> {1202 if Self::can_cast(syntax.kind()) {1203 Some(Self { syntax })1204 } else {1205 None1206 }1207 }1208 fn syntax(&self) -> &SyntaxNode {1209 &self.syntax1210 }1211}1212impl AstNode for ExprIndexExpr {1213 fn can_cast(kind: SyntaxKind) -> bool {1214 kind == EXPR_INDEX_EXPR1215 }1216 fn cast(syntax: SyntaxNode) -> Option<Self> {1217 if Self::can_cast(syntax.kind()) {1218 Some(Self { syntax })1219 } else {1220 None1221 }1222 }1223 fn syntax(&self) -> &SyntaxNode {1224 &self.syntax1225 }1226}1227impl AstNode for ExprApply {1228 fn can_cast(kind: SyntaxKind) -> bool {1229 kind == EXPR_APPLY1230 }1231 fn cast(syntax: SyntaxNode) -> Option<Self> {1232 if Self::can_cast(syntax.kind()) {1233 Some(Self { syntax })1234 } else {1235 None1236 }1237 }1238 fn syntax(&self) -> &SyntaxNode {1239 &self.syntax1240 }1241}1242impl AstNode for ArgsDesc {1243 fn can_cast(kind: SyntaxKind) -> bool {1244 kind == ARGS_DESC1245 }1246 fn cast(syntax: SyntaxNode) -> Option<Self> {1247 if Self::can_cast(syntax.kind()) {1248 Some(Self { syntax })1249 } else {1250 None1251 }1252 }1253 fn syntax(&self) -> &SyntaxNode {1254 &self.syntax1255 }1256}1257impl AstNode for ExprObjExtend {1258 fn can_cast(kind: SyntaxKind) -> bool {1259 kind == EXPR_OBJ_EXTEND1260 }1261 fn cast(syntax: SyntaxNode) -> Option<Self> {1262 if Self::can_cast(syntax.kind()) {1263 Some(Self { syntax })1264 } else {1265 None1266 }1267 }1268 fn syntax(&self) -> &SyntaxNode {1269 &self.syntax1270 }1271}1272impl AstNode for ExprParened {1273 fn can_cast(kind: SyntaxKind) -> bool {1274 kind == EXPR_PARENED1275 }1276 fn cast(syntax: SyntaxNode) -> Option<Self> {1277 if Self::can_cast(syntax.kind()) {1278 Some(Self { syntax })1279 } else {1280 None1281 }1282 }1283 fn syntax(&self) -> &SyntaxNode {1284 &self.syntax1285 }1286}1287impl AstNode for ExprLiteral {1288 fn can_cast(kind: SyntaxKind) -> bool {1289 kind == EXPR_LITERAL1290 }1291 fn cast(syntax: SyntaxNode) -> Option<Self> {1292 if Self::can_cast(syntax.kind()) {1293 Some(Self { syntax })1294 } else {1295 None1296 }1297 }1298 fn syntax(&self) -> &SyntaxNode {1299 &self.syntax1300 }1301}1302impl AstNode for ExprIntrinsicThisFile {1303 fn can_cast(kind: SyntaxKind) -> bool {1304 kind == EXPR_INTRINSIC_THIS_FILE1305 }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 {1314 &self.syntax1315 }1316}1317impl AstNode for ExprIntrinsicId {1318 fn can_cast(kind: SyntaxKind) -> bool {1319 kind == EXPR_INTRINSIC_ID1320 }1321 fn cast(syntax: SyntaxNode) -> Option<Self> {1322 if Self::can_cast(syntax.kind()) {1323 Some(Self { syntax })1324 } else {1325 None1326 }1327 }1328 fn syntax(&self) -> &SyntaxNode {1329 &self.syntax1330 }1331}1332impl AstNode for ExprIntrinsic {1333 fn can_cast(kind: SyntaxKind) -> bool {1334 kind == EXPR_INTRINSIC1335 }1336 fn cast(syntax: SyntaxNode) -> Option<Self> {1337 if Self::can_cast(syntax.kind()) {1338 Some(Self { syntax })1339 } else {1340 None1341 }1342 }1343 fn syntax(&self) -> &SyntaxNode {1344 &self.syntax1345 }1346}1347impl AstNode for ExprString {1348 fn can_cast(kind: SyntaxKind) -> bool {1349 kind == EXPR_STRING1350 }1351 fn cast(syntax: SyntaxNode) -> Option<Self> {1352 if Self::can_cast(syntax.kind()) {1353 Some(Self { syntax })1354 } else {1355 None1356 }1357 }1358 fn syntax(&self) -> &SyntaxNode {1359 &self.syntax1360 }1361}1362impl AstNode for ExprNumber {1363 fn can_cast(kind: SyntaxKind) -> bool {1364 kind == EXPR_NUMBER1365 }1366 fn cast(syntax: SyntaxNode) -> Option<Self> {1367 if Self::can_cast(syntax.kind()) {1368 Some(Self { syntax })1369 } else {1370 None1371 }1372 }1373 fn syntax(&self) -> &SyntaxNode {1374 &self.syntax1375 }1376}1377impl AstNode for ExprArray {1378 fn can_cast(kind: SyntaxKind) -> bool {1379 kind == EXPR_ARRAY1380 }1381 fn cast(syntax: SyntaxNode) -> Option<Self> {1382 if Self::can_cast(syntax.kind()) {1383 Some(Self { syntax })1384 } else {1385 None1386 }1387 }1388 fn syntax(&self) -> &SyntaxNode {1389 &self.syntax1390 }1391}1392impl AstNode for ExprObject {1393 fn can_cast(kind: SyntaxKind) -> bool {1394 kind == EXPR_OBJECT1395 }1396 fn cast(syntax: SyntaxNode) -> Option<Self> {1397 if Self::can_cast(syntax.kind()) {1398 Some(Self { syntax })1399 } else {1400 None1401 }1402 }1403 fn syntax(&self) -> &SyntaxNode {1404 &self.syntax1405 }1406}1407impl AstNode for ExprArrayComp {1408 fn can_cast(kind: SyntaxKind) -> bool {1409 kind == EXPR_ARRAY_COMP1410 }1411 fn cast(syntax: SyntaxNode) -> Option<Self> {1412 if Self::can_cast(syntax.kind()) {1413 Some(Self { syntax })1414 } else {1415 None1416 }1417 }1418 fn syntax(&self) -> &SyntaxNode {1419 &self.syntax1420 }1421}1422impl AstNode for ExprImport {1423 fn can_cast(kind: SyntaxKind) -> bool {1424 kind == EXPR_IMPORT1425 }1426 fn cast(syntax: SyntaxNode) -> Option<Self> {1427 if Self::can_cast(syntax.kind()) {1428 Some(Self { syntax })1429 } else {1430 None1431 }1432 }1433 fn syntax(&self) -> &SyntaxNode {1434 &self.syntax1435 }1436}1437impl AstNode for ExprVar {1438 fn can_cast(kind: SyntaxKind) -> bool {1439 kind == EXPR_VAR1440 }1441 fn cast(syntax: SyntaxNode) -> Option<Self> {1442 if Self::can_cast(syntax.kind()) {1443 Some(Self { syntax })1444 } else {1445 None1446 }1447 }1448 fn syntax(&self) -> &SyntaxNode {1449 &self.syntax1450 }1451}1452impl AstNode for ExprLocal {1453 fn can_cast(kind: SyntaxKind) -> bool {1454 kind == EXPR_LOCAL1455 }1456 fn cast(syntax: SyntaxNode) -> Option<Self> {1457 if Self::can_cast(syntax.kind()) {1458 Some(Self { syntax })1459 } else {1460 None1461 }1462 }1463 fn syntax(&self) -> &SyntaxNode {1464 &self.syntax1465 }1466}1467impl AstNode for ExprIfThenElse {1468 fn can_cast(kind: SyntaxKind) -> bool {1469 kind == EXPR_IF_THEN_ELSE1470 }1471 fn cast(syntax: SyntaxNode) -> Option<Self> {1472 if Self::can_cast(syntax.kind()) {1473 Some(Self { syntax })1474 } else {1475 None1476 }1477 }1478 fn syntax(&self) -> &SyntaxNode {1479 &self.syntax1480 }1481}1482impl AstNode for TrueExpr {1483 fn can_cast(kind: SyntaxKind) -> bool {1484 kind == TRUE_EXPR1485 }1486 fn cast(syntax: SyntaxNode) -> Option<Self> {1487 if Self::can_cast(syntax.kind()) {1488 Some(Self { syntax })1489 } else {1490 None1491 }1492 }1493 fn syntax(&self) -> &SyntaxNode {1494 &self.syntax1495 }1496}1497impl AstNode for FalseExpr {1498 fn can_cast(kind: SyntaxKind) -> bool {1499 kind == FALSE_EXPR1500 }1501 fn cast(syntax: SyntaxNode) -> Option<Self> {1502 if Self::can_cast(syntax.kind()) {1503 Some(Self { syntax })1504 } else {1505 None1506 }1507 }1508 fn syntax(&self) -> &SyntaxNode {1509 &self.syntax1510 }1511}1512impl AstNode for ExprFunction {1513 fn can_cast(kind: SyntaxKind) -> bool {1514 kind == EXPR_FUNCTION1515 }1516 fn cast(syntax: SyntaxNode) -> Option<Self> {1517 if Self::can_cast(syntax.kind()) {1518 Some(Self { syntax })1519 } else {1520 None1521 }1522 }1523 fn syntax(&self) -> &SyntaxNode {1524 &self.syntax1525 }1526}1527impl AstNode for ParamsDesc {1528 fn can_cast(kind: SyntaxKind) -> bool {1529 kind == PARAMS_DESC1530 }1531 fn cast(syntax: SyntaxNode) -> Option<Self> {1532 if Self::can_cast(syntax.kind()) {1533 Some(Self { syntax })1534 } else {1535 None1536 }1537 }1538 fn syntax(&self) -> &SyntaxNode {1539 &self.syntax1540 }1541}1542impl AstNode for ExprAssert {1543 fn can_cast(kind: SyntaxKind) -> bool {1544 kind == EXPR_ASSERT1545 }1546 fn cast(syntax: SyntaxNode) -> Option<Self> {1547 if Self::can_cast(syntax.kind()) {1548 Some(Self { syntax })1549 } else {1550 None1551 }1552 }1553 fn syntax(&self) -> &SyntaxNode {1554 &self.syntax1555 }1556}1557impl AstNode for Assertion {1558 fn can_cast(kind: SyntaxKind) -> bool {1559 kind == ASSERTION1560 }1561 fn cast(syntax: SyntaxNode) -> Option<Self> {1562 if Self::can_cast(syntax.kind()) {1563 Some(Self { syntax })1564 } else {1565 None1566 }1567 }1568 fn syntax(&self) -> &SyntaxNode {1569 &self.syntax1570 }1571}1572impl AstNode for ExprError {1573 fn can_cast(kind: SyntaxKind) -> bool {1574 kind == EXPR_ERROR1575 }1576 fn cast(syntax: SyntaxNode) -> Option<Self> {1577 if Self::can_cast(syntax.kind()) {1578 Some(Self { syntax })1579 } else {1580 None1581 }1582 }1583 fn syntax(&self) -> &SyntaxNode {1584 &self.syntax1585 }1586}1587impl AstNode for SliceDescEnd {1588 fn can_cast(kind: SyntaxKind) -> bool {1589 kind == SLICE_DESC_END1590 }1591 fn cast(syntax: SyntaxNode) -> Option<Self> {1592 if Self::can_cast(syntax.kind()) {1593 Some(Self { syntax })1594 } else {1595 None1596 }1597 }1598 fn syntax(&self) -> &SyntaxNode {1599 &self.syntax1600 }1601}1602impl AstNode for SliceDescStep {1603 fn can_cast(kind: SyntaxKind) -> bool {1604 kind == SLICE_DESC_STEP1605 }1606 fn cast(syntax: SyntaxNode) -> Option<Self> {1607 if Self::can_cast(syntax.kind()) {1608 Some(Self { syntax })1609 } else {1610 None1611 }1612 }1613 fn syntax(&self) -> &SyntaxNode {1614 &self.syntax1615 }1616}1617impl AstNode for Arg {1618 fn can_cast(kind: SyntaxKind) -> bool {1619 kind == ARG1620 }1621 fn cast(syntax: SyntaxNode) -> Option<Self> {1622 if Self::can_cast(syntax.kind()) {1623 Some(Self { syntax })1624 } else {1625 None1626 }1627 }1628 fn syntax(&self) -> &SyntaxNode {1629 &self.syntax1630 }1631}1632impl AstNode for ObjBodyComp {1633 fn can_cast(kind: SyntaxKind) -> bool {1634 kind == OBJ_BODY_COMP1635 }1636 fn cast(syntax: SyntaxNode) -> Option<Self> {1637 if Self::can_cast(syntax.kind()) {1638 Some(Self { syntax })1639 } else {1640 None1641 }1642 }1643 fn syntax(&self) -> &SyntaxNode {1644 &self.syntax1645 }1646}1647impl AstNode for ObjLocalPostComma {1648 fn can_cast(kind: SyntaxKind) -> bool {1649 kind == OBJ_LOCAL_POST_COMMA1650 }1651 fn cast(syntax: SyntaxNode) -> Option<Self> {1652 if Self::can_cast(syntax.kind()) {1653 Some(Self { syntax })1654 } else {1655 None1656 }1657 }1658 fn syntax(&self) -> &SyntaxNode {1659 &self.syntax1660 }1661}1662impl AstNode for ObjLocalPreComma {1663 fn can_cast(kind: SyntaxKind) -> bool {1664 kind == OBJ_LOCAL_PRE_COMMA1665 }1666 fn cast(syntax: SyntaxNode) -> Option<Self> {1667 if Self::can_cast(syntax.kind()) {1668 Some(Self { syntax })1669 } else {1670 None1671 }1672 }1673 fn syntax(&self) -> &SyntaxNode {1674 &self.syntax1675 }1676}1677impl AstNode for ObjBodyMemberList {1678 fn can_cast(kind: SyntaxKind) -> bool {1679 kind == OBJ_BODY_MEMBER_LIST1680 }1681 fn cast(syntax: SyntaxNode) -> Option<Self> {1682 if Self::can_cast(syntax.kind()) {1683 Some(Self { syntax })1684 } else {1685 None1686 }1687 }1688 fn syntax(&self) -> &SyntaxNode {1689 &self.syntax1690 }1691}1692impl AstNode for ObjLocal {1693 fn can_cast(kind: SyntaxKind) -> bool {1694 kind == OBJ_LOCAL1695 }1696 fn cast(syntax: SyntaxNode) -> Option<Self> {1697 if Self::can_cast(syntax.kind()) {1698 Some(Self { syntax })1699 } else {1700 None1701 }1702 }1703 fn syntax(&self) -> &SyntaxNode {1704 &self.syntax1705 }1706}1707impl AstNode for MemberBindStmt {1708 fn can_cast(kind: SyntaxKind) -> bool {1709 kind == MEMBER_BIND_STMT1710 }1711 fn cast(syntax: SyntaxNode) -> Option<Self> {1712 if Self::can_cast(syntax.kind()) {1713 Some(Self { syntax })1714 } else {1715 None1716 }1717 }1718 fn syntax(&self) -> &SyntaxNode {1719 &self.syntax1720 }1721}1722impl AstNode for MemberAssertStmt {1723 fn can_cast(kind: SyntaxKind) -> bool {1724 kind == MEMBER_ASSERT_STMT1725 }1726 fn cast(syntax: SyntaxNode) -> Option<Self> {1727 if Self::can_cast(syntax.kind()) {1728 Some(Self { syntax })1729 } else {1730 None1731 }1732 }1733 fn syntax(&self) -> &SyntaxNode {1734 &self.syntax1735 }1736}1737impl AstNode for MemberField {1738 fn can_cast(kind: SyntaxKind) -> bool {1739 kind == MEMBER_FIELD1740 }1741 fn cast(syntax: SyntaxNode) -> Option<Self> {1742 if Self::can_cast(syntax.kind()) {1743 Some(Self { syntax })1744 } else {1745 None1746 }1747 }1748 fn syntax(&self) -> &SyntaxNode {1749 &self.syntax1750 }1751}1752impl AstNode for FieldNormal {1753 fn can_cast(kind: SyntaxKind) -> bool {1754 kind == FIELD_NORMAL1755 }1756 fn cast(syntax: SyntaxNode) -> Option<Self> {1757 if Self::can_cast(syntax.kind()) {1758 Some(Self { syntax })1759 } else {1760 None1761 }1762 }1763 fn syntax(&self) -> &SyntaxNode {1764 &self.syntax1765 }1766}1767impl AstNode for FieldMethod {1768 fn can_cast(kind: SyntaxKind) -> bool {1769 kind == FIELD_METHOD1770 }1771 fn cast(syntax: SyntaxNode) -> Option<Self> {1772 if Self::can_cast(syntax.kind()) {1773 Some(Self { syntax })1774 } else {1775 None1776 }1777 }1778 fn syntax(&self) -> &SyntaxNode {1779 &self.syntax1780 }1781}1782impl AstNode for FieldNameFixed {1783 fn can_cast(kind: SyntaxKind) -> bool {1784 kind == FIELD_NAME_FIXED1785 }1786 fn cast(syntax: SyntaxNode) -> Option<Self> {1787 if Self::can_cast(syntax.kind()) {1788 Some(Self { syntax })1789 } else {1790 None1791 }1792 }1793 fn syntax(&self) -> &SyntaxNode {1794 &self.syntax1795 }1796}1797impl AstNode for FieldNameDynamic {1798 fn can_cast(kind: SyntaxKind) -> bool {1799 kind == FIELD_NAME_DYNAMIC1800 }1801 fn cast(syntax: SyntaxNode) -> Option<Self> {1802 if Self::can_cast(syntax.kind()) {1803 Some(Self { syntax })1804 } else {1805 None1806 }1807 }1808 fn syntax(&self) -> &SyntaxNode {1809 &self.syntax1810 }1811}1812impl AstNode for ForSpec {1813 fn can_cast(kind: SyntaxKind) -> bool {1814 kind == FOR_SPEC1815 }1816 fn cast(syntax: SyntaxNode) -> Option<Self> {1817 if Self::can_cast(syntax.kind()) {1818 Some(Self { syntax })1819 } else {1820 None1821 }1822 }1823 fn syntax(&self) -> &SyntaxNode {1824 &self.syntax1825 }1826}1827impl AstNode for IfSpec {1828 fn can_cast(kind: SyntaxKind) -> bool {1829 kind == IF_SPEC1830 }1831 fn cast(syntax: SyntaxNode) -> Option<Self> {1832 if Self::can_cast(syntax.kind()) {1833 Some(Self { syntax })1834 } else {1835 None1836 }1837 }1838 fn syntax(&self) -> &SyntaxNode {1839 &self.syntax1840 }1841}1842impl AstNode for BindDestruct {1843 fn can_cast(kind: SyntaxKind) -> bool {1844 kind == BIND_DESTRUCT1845 }1846 fn cast(syntax: SyntaxNode) -> Option<Self> {1847 if Self::can_cast(syntax.kind()) {1848 Some(Self { syntax })1849 } else {1850 None1851 }1852 }1853 fn syntax(&self) -> &SyntaxNode {1854 &self.syntax1855 }1856}1857impl AstNode for BindFunction {1858 fn can_cast(kind: SyntaxKind) -> bool {1859 kind == BIND_FUNCTION1860 }1861 fn cast(syntax: SyntaxNode) -> Option<Self> {1862 if Self::can_cast(syntax.kind()) {1863 Some(Self { syntax })1864 } else {1865 None1866 }1867 }1868 fn syntax(&self) -> &SyntaxNode {1869 &self.syntax1870 }1871}1872impl AstNode for Param {1873 fn can_cast(kind: SyntaxKind) -> bool {1874 kind == PARAM1875 }1876 fn cast(syntax: SyntaxNode) -> Option<Self> {1877 if Self::can_cast(syntax.kind()) {1878 Some(Self { syntax })1879 } else {1880 None1881 }1882 }1883 fn syntax(&self) -> &SyntaxNode {1884 &self.syntax1885 }1886}1887impl AstNode for DestructFull {1888 fn can_cast(kind: SyntaxKind) -> bool {1889 kind == DESTRUCT_FULL1890 }1891 fn cast(syntax: SyntaxNode) -> Option<Self> {1892 if Self::can_cast(syntax.kind()) {1893 Some(Self { syntax })1894 } else {1895 None1896 }1897 }1898 fn syntax(&self) -> &SyntaxNode {1899 &self.syntax1900 }1901}1902impl AstNode for DestructSkip {1903 fn can_cast(kind: SyntaxKind) -> bool {1904 kind == DESTRUCT_SKIP1905 }1906 fn cast(syntax: SyntaxNode) -> Option<Self> {1907 if Self::can_cast(syntax.kind()) {1908 Some(Self { syntax })1909 } else {1910 None1911 }1912 }1913 fn syntax(&self) -> &SyntaxNode {1914 &self.syntax1915 }1916}1917impl AstNode for DestructArray {1918 fn can_cast(kind: SyntaxKind) -> bool {1919 kind == DESTRUCT_ARRAY1920 }1921 fn cast(syntax: SyntaxNode) -> Option<Self> {1922 if Self::can_cast(syntax.kind()) {1923 Some(Self { syntax })1924 } else {1925 None1926 }1927 }1928 fn syntax(&self) -> &SyntaxNode {1929 &self.syntax1930 }1931}1932impl AstNode for DestructObject {1933 fn can_cast(kind: SyntaxKind) -> bool {1934 kind == DESTRUCT_OBJECT1935 }1936 fn cast(syntax: SyntaxNode) -> Option<Self> {1937 if Self::can_cast(syntax.kind()) {1938 Some(Self { syntax })1939 } else {1940 None1941 }1942 }1943 fn syntax(&self) -> &SyntaxNode {1944 &self.syntax1945 }1946}1947impl AstNode for DestructObjectField {1948 fn can_cast(kind: SyntaxKind) -> bool {1949 kind == DESTRUCT_OBJECT_FIELD1950 }1951 fn cast(syntax: SyntaxNode) -> Option<Self> {1952 if Self::can_cast(syntax.kind()) {1953 Some(Self { syntax })1954 } else {1955 None1956 }1957 }1958 fn syntax(&self) -> &SyntaxNode {1959 &self.syntax1960 }1961}1962impl AstNode for DestructRest {1963 fn can_cast(kind: SyntaxKind) -> bool {1964 kind == DESTRUCT_REST1965 }1966 fn cast(syntax: SyntaxNode) -> Option<Self> {1967 if Self::can_cast(syntax.kind()) {1968 Some(Self { syntax })1969 } else {1970 None1971 }1972 }1973 fn syntax(&self) -> &SyntaxNode {1974 &self.syntax1975 }1976}1977impl AstNode for DestructArrayElement {1978 fn can_cast(kind: SyntaxKind) -> bool {1979 kind == DESTRUCT_ARRAY_ELEMENT1980 }1981 fn cast(syntax: SyntaxNode) -> Option<Self> {1982 if Self::can_cast(syntax.kind()) {1983 Some(Self { syntax })1984 } else {1985 None1986 }1987 }1988 fn syntax(&self) -> &SyntaxNode {1989 &self.syntax1990 }1991}1992impl From<ExprBinary> for Expr {1993 fn from(node: ExprBinary) -> Expr {1994 Expr::ExprBinary(node)1995 }1996}1997impl From<ExprUnary> for Expr {1998 fn from(node: ExprUnary) -> Expr {1999 Expr::ExprUnary(node)2000 }2001}2002impl From<ExprSlice> for Expr {2003 fn from(node: ExprSlice) -> Expr {2004 Expr::ExprSlice(node)2005 }2006}2007impl From<ExprIndex> for Expr {2008 fn from(node: ExprIndex) -> Expr {2009 Expr::ExprIndex(node)2010 }2011}2012impl From<ExprIndexExpr> for Expr {2013 fn from(node: ExprIndexExpr) -> Expr {2014 Expr::ExprIndexExpr(node)2015 }2016}2017impl From<ExprApply> for Expr {2018 fn from(node: ExprApply) -> Expr {2019 Expr::ExprApply(node)2020 }2021}2022impl From<ExprObjExtend> for Expr {2023 fn from(node: ExprObjExtend) -> Expr {2024 Expr::ExprObjExtend(node)2025 }2026}2027impl From<ExprParened> for Expr {2028 fn from(node: ExprParened) -> Expr {2029 Expr::ExprParened(node)2030 }2031}2032impl From<ExprIntrinsicThisFile> for Expr {2033 fn from(node: ExprIntrinsicThisFile) -> Expr {2034 Expr::ExprIntrinsicThisFile(node)2035 }2036}2037impl From<ExprIntrinsicId> for Expr {2038 fn from(node: ExprIntrinsicId) -> Expr {2039 Expr::ExprIntrinsicId(node)2040 }2041}2042impl From<ExprIntrinsic> for Expr {2043 fn from(node: ExprIntrinsic) -> Expr {2044 Expr::ExprIntrinsic(node)2045 }2046}2047impl From<ExprString> for Expr {2048 fn from(node: ExprString) -> Expr {2049 Expr::ExprString(node)2050 }2051}2052impl From<ExprNumber> for Expr {2053 fn from(node: ExprNumber) -> Expr {2054 Expr::ExprNumber(node)2055 }2056}2057impl From<ExprLiteral> for Expr {2058 fn from(node: ExprLiteral) -> Expr {2059 Expr::ExprLiteral(node)2060 }2061}2062impl From<ExprArray> for Expr {2063 fn from(node: ExprArray) -> Expr {2064 Expr::ExprArray(node)2065 }2066}2067impl From<ExprObject> for Expr {2068 fn from(node: ExprObject) -> Expr {2069 Expr::ExprObject(node)2070 }2071}2072impl From<ExprArrayComp> for Expr {2073 fn from(node: ExprArrayComp) -> Expr {2074 Expr::ExprArrayComp(node)2075 }2076}2077impl From<ExprImport> for Expr {2078 fn from(node: ExprImport) -> Expr {2079 Expr::ExprImport(node)2080 }2081}2082impl From<ExprVar> for Expr {2083 fn from(node: ExprVar) -> Expr {2084 Expr::ExprVar(node)2085 }2086}2087impl From<ExprLocal> for Expr {2088 fn from(node: ExprLocal) -> Expr {2089 Expr::ExprLocal(node)2090 }2091}2092impl From<ExprIfThenElse> for Expr {2093 fn from(node: ExprIfThenElse) -> Expr {2094 Expr::ExprIfThenElse(node)2095 }2096}2097impl From<ExprFunction> for Expr {2098 fn from(node: ExprFunction) -> Expr {2099 Expr::ExprFunction(node)2100 }2101}2102impl From<ExprAssert> for Expr {2103 fn from(node: ExprAssert) -> Expr {2104 Expr::ExprAssert(node)2105 }2106}2107impl From<ExprError> for Expr {2108 fn from(node: ExprError) -> Expr {2109 Expr::ExprError(node)2110 }2111}2112impl AstNode for Expr {2113 fn can_cast(kind: SyntaxKind) -> bool {2114 match kind {2115 EXPR_BINARY2116 | EXPR_UNARY2117 | EXPR_SLICE2118 | EXPR_INDEX2119 | EXPR_INDEX_EXPR2120 | EXPR_APPLY2121 | EXPR_OBJ_EXTEND2122 | EXPR_PARENED2123 | EXPR_INTRINSIC_THIS_FILE2124 | EXPR_INTRINSIC_ID2125 | EXPR_INTRINSIC2126 | EXPR_STRING2127 | EXPR_NUMBER2128 | EXPR_LITERAL2129 | EXPR_ARRAY2130 | EXPR_OBJECT2131 | EXPR_ARRAY_COMP2132 | EXPR_IMPORT2133 | EXPR_VAR2134 | EXPR_LOCAL2135 | EXPR_IF_THEN_ELSE2136 | EXPR_FUNCTION2137 | EXPR_ASSERT2138 | EXPR_ERROR => true,2139 _ => false,2140 }2141 }2142 fn cast(syntax: SyntaxNode) -> Option<Self> {2143 let res = match syntax.kind() {2144 EXPR_BINARY => Expr::ExprBinary(ExprBinary { syntax }),2145 EXPR_UNARY => Expr::ExprUnary(ExprUnary { syntax }),2146 EXPR_SLICE => Expr::ExprSlice(ExprSlice { syntax }),2147 EXPR_INDEX => Expr::ExprIndex(ExprIndex { syntax }),2148 EXPR_INDEX_EXPR => Expr::ExprIndexExpr(ExprIndexExpr { syntax }),2149 EXPR_APPLY => Expr::ExprApply(ExprApply { syntax }),2150 EXPR_OBJ_EXTEND => Expr::ExprObjExtend(ExprObjExtend { syntax }),2151 EXPR_PARENED => Expr::ExprParened(ExprParened { syntax }),2152 EXPR_INTRINSIC_THIS_FILE => {2153 Expr::ExprIntrinsicThisFile(ExprIntrinsicThisFile { syntax })2154 }2155 EXPR_INTRINSIC_ID => Expr::ExprIntrinsicId(ExprIntrinsicId { syntax }),2156 EXPR_INTRINSIC => Expr::ExprIntrinsic(ExprIntrinsic { syntax }),2157 EXPR_STRING => Expr::ExprString(ExprString { syntax }),2158 EXPR_NUMBER => Expr::ExprNumber(ExprNumber { syntax }),2159 EXPR_LITERAL => Expr::ExprLiteral(ExprLiteral { syntax }),2160 EXPR_ARRAY => Expr::ExprArray(ExprArray { syntax }),2161 EXPR_OBJECT => Expr::ExprObject(ExprObject { syntax }),2162 EXPR_ARRAY_COMP => Expr::ExprArrayComp(ExprArrayComp { syntax }),2163 EXPR_IMPORT => Expr::ExprImport(ExprImport { syntax }),2164 EXPR_VAR => Expr::ExprVar(ExprVar { syntax }),2165 EXPR_LOCAL => Expr::ExprLocal(ExprLocal { syntax }),2166 EXPR_IF_THEN_ELSE => Expr::ExprIfThenElse(ExprIfThenElse { syntax }),2167 EXPR_FUNCTION => Expr::ExprFunction(ExprFunction { syntax }),2168 EXPR_ASSERT => Expr::ExprAssert(ExprAssert { syntax }),2169 EXPR_ERROR => Expr::ExprError(ExprError { syntax }),2170 _ => return None,2171 };2172 Some(res)2173 }2174 fn syntax(&self) -> &SyntaxNode {2175 match self {2176 Expr::ExprBinary(it) => &it.syntax,2177 Expr::ExprUnary(it) => &it.syntax,2178 Expr::ExprSlice(it) => &it.syntax,2179 Expr::ExprIndex(it) => &it.syntax,2180 Expr::ExprIndexExpr(it) => &it.syntax,2181 Expr::ExprApply(it) => &it.syntax,2182 Expr::ExprObjExtend(it) => &it.syntax,2183 Expr::ExprParened(it) => &it.syntax,2184 Expr::ExprIntrinsicThisFile(it) => &it.syntax,2185 Expr::ExprIntrinsicId(it) => &it.syntax,2186 Expr::ExprIntrinsic(it) => &it.syntax,2187 Expr::ExprString(it) => &it.syntax,2188 Expr::ExprNumber(it) => &it.syntax,2189 Expr::ExprLiteral(it) => &it.syntax,2190 Expr::ExprArray(it) => &it.syntax,2191 Expr::ExprObject(it) => &it.syntax,2192 Expr::ExprArrayComp(it) => &it.syntax,2193 Expr::ExprImport(it) => &it.syntax,2194 Expr::ExprVar(it) => &it.syntax,2195 Expr::ExprLocal(it) => &it.syntax,2196 Expr::ExprIfThenElse(it) => &it.syntax,2197 Expr::ExprFunction(it) => &it.syntax,2198 Expr::ExprAssert(it) => &it.syntax,2199 Expr::ExprError(it) => &it.syntax,2200 }2201 }2202}2203impl From<ObjBodyComp> for ObjBody {2204 fn from(node: ObjBodyComp) -> ObjBody {2205 ObjBody::ObjBodyComp(node)2206 }2207}2208impl From<ObjBodyMemberList> for ObjBody {2209 fn from(node: ObjBodyMemberList) -> ObjBody {2210 ObjBody::ObjBodyMemberList(node)2211 }2212}2213impl AstNode for ObjBody {2214 fn can_cast(kind: SyntaxKind) -> bool {2215 match kind {2216 OBJ_BODY_COMP | OBJ_BODY_MEMBER_LIST => true,2217 _ => false,2218 }2219 }2220 fn cast(syntax: SyntaxNode) -> Option<Self> {2221 let res = match syntax.kind() {2222 OBJ_BODY_COMP => ObjBody::ObjBodyComp(ObjBodyComp { syntax }),2223 OBJ_BODY_MEMBER_LIST => ObjBody::ObjBodyMemberList(ObjBodyMemberList { syntax }),2224 _ => return None,2225 };2226 Some(res)2227 }2228 fn syntax(&self) -> &SyntaxNode {2229 match self {2230 ObjBody::ObjBodyComp(it) => &it.syntax,2231 ObjBody::ObjBodyMemberList(it) => &it.syntax,2232 }2233 }2234}2235impl From<ForSpec> for CompSpec {2236 fn from(node: ForSpec) -> CompSpec {2237 CompSpec::ForSpec(node)2238 }2239}2240impl From<IfSpec> for CompSpec {2241 fn from(node: IfSpec) -> CompSpec {2242 CompSpec::IfSpec(node)2243 }2244}2245impl AstNode for CompSpec {2246 fn can_cast(kind: SyntaxKind) -> bool {2247 match kind {2248 FOR_SPEC | IF_SPEC => true,2249 _ => false,2250 }2251 }2252 fn cast(syntax: SyntaxNode) -> Option<Self> {2253 let res = match syntax.kind() {2254 FOR_SPEC => CompSpec::ForSpec(ForSpec { syntax }),2255 IF_SPEC => CompSpec::IfSpec(IfSpec { syntax }),2256 _ => return None,2257 };2258 Some(res)2259 }2260 fn syntax(&self) -> &SyntaxNode {2261 match self {2262 CompSpec::ForSpec(it) => &it.syntax,2263 CompSpec::IfSpec(it) => &it.syntax,2264 }2265 }2266}2267impl From<BindDestruct> for Bind {2268 fn from(node: BindDestruct) -> Bind {2269 Bind::BindDestruct(node)2270 }2271}2272impl From<BindFunction> for Bind {2273 fn from(node: BindFunction) -> Bind {2274 Bind::BindFunction(node)2275 }2276}2277impl AstNode for Bind {2278 fn can_cast(kind: SyntaxKind) -> bool {2279 match kind {2280 BIND_DESTRUCT | BIND_FUNCTION => true,2281 _ => false,2282 }2283 }2284 fn cast(syntax: SyntaxNode) -> Option<Self> {2285 let res = match syntax.kind() {2286 BIND_DESTRUCT => Bind::BindDestruct(BindDestruct { syntax }),2287 BIND_FUNCTION => Bind::BindFunction(BindFunction { syntax }),2288 _ => return None,2289 };2290 Some(res)2291 }2292 fn syntax(&self) -> &SyntaxNode {2293 match self {2294 Bind::BindDestruct(it) => &it.syntax,2295 Bind::BindFunction(it) => &it.syntax,2296 }2297 }2298}2299impl From<MemberBindStmt> for Member {2300 fn from(node: MemberBindStmt) -> Member {2301 Member::MemberBindStmt(node)2302 }2303}2304impl From<MemberAssertStmt> for Member {2305 fn from(node: MemberAssertStmt) -> Member {2306 Member::MemberAssertStmt(node)2307 }2308}2309impl From<MemberField> for Member {2310 fn from(node: MemberField) -> Member {2311 Member::MemberField(node)2312 }2313}2314impl AstNode for Member {2315 fn can_cast(kind: SyntaxKind) -> bool {2316 match kind {2317 MEMBER_BIND_STMT | MEMBER_ASSERT_STMT | MEMBER_FIELD => true,2318 _ => false,2319 }2320 }2321 fn cast(syntax: SyntaxNode) -> Option<Self> {2322 let res = match syntax.kind() {2323 MEMBER_BIND_STMT => Member::MemberBindStmt(MemberBindStmt { syntax }),2324 MEMBER_ASSERT_STMT => Member::MemberAssertStmt(MemberAssertStmt { syntax }),2325 MEMBER_FIELD => Member::MemberField(MemberField { syntax }),2326 _ => return None,2327 };2328 Some(res)2329 }2330 fn syntax(&self) -> &SyntaxNode {2331 match self {2332 Member::MemberBindStmt(it) => &it.syntax,2333 Member::MemberAssertStmt(it) => &it.syntax,2334 Member::MemberField(it) => &it.syntax,2335 }2336 }2337}2338impl From<FieldNormal> for Field {2339 fn from(node: FieldNormal) -> Field {2340 Field::FieldNormal(node)2341 }2342}2343impl From<FieldMethod> for Field {2344 fn from(node: FieldMethod) -> Field {2345 Field::FieldMethod(node)2346 }2347}2348impl AstNode for Field {2349 fn can_cast(kind: SyntaxKind) -> bool {2350 match kind {2351 FIELD_NORMAL | FIELD_METHOD => true,2352 _ => false,2353 }2354 }2355 fn cast(syntax: SyntaxNode) -> Option<Self> {2356 let res = match syntax.kind() {2357 FIELD_NORMAL => Field::FieldNormal(FieldNormal { syntax }),2358 FIELD_METHOD => Field::FieldMethod(FieldMethod { syntax }),2359 _ => return None,2360 };2361 Some(res)2362 }2363 fn syntax(&self) -> &SyntaxNode {2364 match self {2365 Field::FieldNormal(it) => &it.syntax,2366 Field::FieldMethod(it) => &it.syntax,2367 }2368 }2369}2370impl From<FieldNameFixed> for FieldName {2371 fn from(node: FieldNameFixed) -> FieldName {2372 FieldName::FieldNameFixed(node)2373 }2374}2375impl From<FieldNameDynamic> for FieldName {2376 fn from(node: FieldNameDynamic) -> FieldName {2377 FieldName::FieldNameDynamic(node)2378 }2379}2380impl AstNode for FieldName {2381 fn can_cast(kind: SyntaxKind) -> bool {2382 match kind {2383 FIELD_NAME_FIXED | FIELD_NAME_DYNAMIC => true,2384 _ => false,2385 }2386 }2387 fn cast(syntax: SyntaxNode) -> Option<Self> {2388 let res = match syntax.kind() {2389 FIELD_NAME_FIXED => FieldName::FieldNameFixed(FieldNameFixed { syntax }),2390 FIELD_NAME_DYNAMIC => FieldName::FieldNameDynamic(FieldNameDynamic { syntax }),2391 _ => return None,2392 };2393 Some(res)2394 }2395 fn syntax(&self) -> &SyntaxNode {2396 match self {2397 FieldName::FieldNameFixed(it) => &it.syntax,2398 FieldName::FieldNameDynamic(it) => &it.syntax,2399 }2400 }2401}2402impl From<DestructFull> for Destruct {2403 fn from(node: DestructFull) -> Destruct {2404 Destruct::DestructFull(node)2405 }2406}2407impl From<DestructSkip> for Destruct {2408 fn from(node: DestructSkip) -> Destruct {2409 Destruct::DestructSkip(node)2410 }2411}2412impl From<DestructArray> for Destruct {2413 fn from(node: DestructArray) -> Destruct {2414 Destruct::DestructArray(node)2415 }2416}2417impl From<DestructObject> for Destruct {2418 fn from(node: DestructObject) -> Destruct {2419 Destruct::DestructObject(node)2420 }2421}2422impl AstNode for Destruct {2423 fn can_cast(kind: SyntaxKind) -> bool {2424 match kind {2425 DESTRUCT_FULL | DESTRUCT_SKIP | DESTRUCT_ARRAY | DESTRUCT_OBJECT => true,2426 _ => false,2427 }2428 }2429 fn cast(syntax: SyntaxNode) -> Option<Self> {2430 let res = match syntax.kind() {2431 DESTRUCT_FULL => Destruct::DestructFull(DestructFull { syntax }),2432 DESTRUCT_SKIP => Destruct::DestructSkip(DestructSkip { syntax }),2433 DESTRUCT_ARRAY => Destruct::DestructArray(DestructArray { syntax }),2434 DESTRUCT_OBJECT => Destruct::DestructObject(DestructObject { syntax }),2435 _ => return None,2436 };2437 Some(res)2438 }2439 fn syntax(&self) -> &SyntaxNode {2440 match self {2441 Destruct::DestructFull(it) => &it.syntax,2442 Destruct::DestructSkip(it) => &it.syntax,2443 Destruct::DestructArray(it) => &it.syntax,2444 Destruct::DestructObject(it) => &it.syntax,2445 }2446 }2447}2448impl From<DestructArrayElement> for DestructArrayPart {2449 fn from(node: DestructArrayElement) -> DestructArrayPart {2450 DestructArrayPart::DestructArrayElement(node)2451 }2452}2453impl From<DestructRest> for DestructArrayPart {2454 fn from(node: DestructRest) -> DestructArrayPart {2455 DestructArrayPart::DestructRest(node)2456 }2457}2458impl AstNode for DestructArrayPart {2459 fn can_cast(kind: SyntaxKind) -> bool {2460 match kind {2461 DESTRUCT_ARRAY_ELEMENT | DESTRUCT_REST => true,2462 _ => false,2463 }2464 }2465 fn cast(syntax: SyntaxNode) -> Option<Self> {2466 let res = match syntax.kind() {2467 DESTRUCT_ARRAY_ELEMENT => {2468 DestructArrayPart::DestructArrayElement(DestructArrayElement { syntax })2469 }2470 DESTRUCT_REST => DestructArrayPart::DestructRest(DestructRest { syntax }),2471 _ => return None,2472 };2473 Some(res)2474 }2475 fn syntax(&self) -> &SyntaxNode {2476 match self {2477 DestructArrayPart::DestructArrayElement(it) => &it.syntax,2478 DestructArrayPart::DestructRest(it) => &it.syntax,2479 }2480 }2481}2482impl AstToken for BinaryOperator {2483 fn can_cast(kind: SyntaxKind) -> bool {2484 match kind {2485 OR | AND | BIT_OR | BIT_XOR | BIT_AND | EQ | NE | LT | GT | LE | GE | IN_KW | LHS2486 | RHS | PLUS | MINUS | MUL | DIV | MODULO | ERROR_NO_OPERATOR => true,2487 _ => false,2488 }2489 }2490 fn cast(syntax: SyntaxToken) -> Option<Self> {2491 let res = match syntax.kind() {2492 OR => BinaryOperator {2493 syntax,2494 kind: BinaryOperatorKind::Or,2495 },2496 AND => BinaryOperator {2497 syntax,2498 kind: BinaryOperatorKind::And,2499 },2500 BIT_OR => BinaryOperator {2501 syntax,2502 kind: BinaryOperatorKind::BitOr,2503 },2504 BIT_XOR => BinaryOperator {2505 syntax,2506 kind: BinaryOperatorKind::BitXor,2507 },2508 BIT_AND => BinaryOperator {2509 syntax,2510 kind: BinaryOperatorKind::BitAnd,2511 },2512 EQ => BinaryOperator {2513 syntax,2514 kind: BinaryOperatorKind::Eq,2515 },2516 NE => BinaryOperator {2517 syntax,2518 kind: BinaryOperatorKind::Ne,2519 },2520 LT => BinaryOperator {2521 syntax,2522 kind: BinaryOperatorKind::Lt,2523 },2524 GT => BinaryOperator {2525 syntax,2526 kind: BinaryOperatorKind::Gt,2527 },2528 LE => BinaryOperator {2529 syntax,2530 kind: BinaryOperatorKind::Le,2531 },2532 GE => BinaryOperator {2533 syntax,2534 kind: BinaryOperatorKind::Ge,2535 },2536 IN_KW => BinaryOperator {2537 syntax,2538 kind: BinaryOperatorKind::InKw,2539 },2540 LHS => BinaryOperator {2541 syntax,2542 kind: BinaryOperatorKind::Lhs,2543 },2544 RHS => BinaryOperator {2545 syntax,2546 kind: BinaryOperatorKind::Rhs,2547 },2548 PLUS => BinaryOperator {2549 syntax,2550 kind: BinaryOperatorKind::Plus,2551 },2552 MINUS => BinaryOperator {2553 syntax,2554 kind: BinaryOperatorKind::Minus,2555 },2556 MUL => BinaryOperator {2557 syntax,2558 kind: BinaryOperatorKind::Mul,2559 },2560 DIV => BinaryOperator {2561 syntax,2562 kind: BinaryOperatorKind::Div,2563 },2564 MODULO => BinaryOperator {2565 syntax,2566 kind: BinaryOperatorKind::Modulo,2567 },2568 ERROR_NO_OPERATOR => BinaryOperator {2569 syntax,2570 kind: BinaryOperatorKind::ErrorNoOperator,2571 },2572 _ => return None,2573 };2574 Some(res)2575 }2576 fn syntax(&self) -> &SyntaxToken {2577 &self.syntax2578 }2579}2580impl BinaryOperator {2581 pub fn kind(&self) -> BinaryOperatorKind {2582 self.kind2583 }2584}2585impl std::fmt::Display for BinaryOperator {2586 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2587 std::fmt::Display::fmt(self.syntax(), f)2588 }2589}2590impl AstToken for UnaryOperator {2591 fn can_cast(kind: SyntaxKind) -> bool {2592 match kind {2593 MINUS | NOT | BIT_NOT => true,2594 _ => false,2595 }2596 }2597 fn cast(syntax: SyntaxToken) -> Option<Self> {2598 let res = match syntax.kind() {2599 MINUS => UnaryOperator {2600 syntax,2601 kind: UnaryOperatorKind::Minus,2602 },2603 NOT => UnaryOperator {2604 syntax,2605 kind: UnaryOperatorKind::Not,2606 },2607 BIT_NOT => UnaryOperator {2608 syntax,2609 kind: UnaryOperatorKind::BitNot,2610 },2611 _ => return None,2612 };2613 Some(res)2614 }2615 fn syntax(&self) -> &SyntaxToken {2616 &self.syntax2617 }2618}2619impl UnaryOperator {2620 pub fn kind(&self) -> UnaryOperatorKind {2621 self.kind2622 }2623}2624impl std::fmt::Display for UnaryOperator {2625 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2626 std::fmt::Display::fmt(self.syntax(), f)2627 }2628}2629impl AstToken for Literal {2630 fn can_cast(kind: SyntaxKind) -> bool {2631 match kind {2632 NULL_KW | TRUE_KW | FALSE_KW | SELF_KW | DOLLAR | SUPER_KW => true,2633 _ => false,2634 }2635 }2636 fn cast(syntax: SyntaxToken) -> Option<Self> {2637 let res = match syntax.kind() {2638 NULL_KW => Literal {2639 syntax,2640 kind: LiteralKind::NullKw,2641 },2642 TRUE_KW => Literal {2643 syntax,2644 kind: LiteralKind::TrueKw,2645 },2646 FALSE_KW => Literal {2647 syntax,2648 kind: LiteralKind::FalseKw,2649 },2650 SELF_KW => Literal {2651 syntax,2652 kind: LiteralKind::SelfKw,2653 },2654 DOLLAR => Literal {2655 syntax,2656 kind: LiteralKind::Dollar,2657 },2658 SUPER_KW => Literal {2659 syntax,2660 kind: LiteralKind::SuperKw,2661 },2662 _ => return None,2663 };2664 Some(res)2665 }2666 fn syntax(&self) -> &SyntaxToken {2667 &self.syntax2668 }2669}2670impl Literal {2671 pub fn kind(&self) -> LiteralKind {2672 self.kind2673 }2674}2675impl std::fmt::Display for Literal {2676 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2677 std::fmt::Display::fmt(self.syntax(), f)2678 }2679}2680impl AstToken for String {2681 fn can_cast(kind: SyntaxKind) -> bool {2682 match kind {2683 STRING_DOUBLE2684 | STRING_SINGLE2685 | STRING_DOUBLE_VERBATIM2686 | STRING_SINGLE_VERBATIM2687 | STRING_BLOCK => true,2688 _ => false,2689 }2690 }2691 fn cast(syntax: SyntaxToken) -> Option<Self> {2692 let res = match syntax.kind() {2693 STRING_DOUBLE => String {2694 syntax,2695 kind: StringKind::StringDouble,2696 },2697 STRING_SINGLE => String {2698 syntax,2699 kind: StringKind::StringSingle,2700 },2701 STRING_DOUBLE_VERBATIM => String {2702 syntax,2703 kind: StringKind::StringDoubleVerbatim,2704 },2705 STRING_SINGLE_VERBATIM => String {2706 syntax,2707 kind: StringKind::StringSingleVerbatim,2708 },2709 STRING_BLOCK => String {2710 syntax,2711 kind: StringKind::StringBlock,2712 },2713 _ => return None,2714 };2715 Some(res)2716 }2717 fn syntax(&self) -> &SyntaxToken {2718 &self.syntax2719 }2720}2721impl String {2722 pub fn kind(&self) -> StringKind {2723 self.kind2724 }2725}2726impl std::fmt::Display for String {2727 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2728 std::fmt::Display::fmt(self.syntax(), f)2729 }2730}2731impl AstToken for Number {2732 fn can_cast(kind: SyntaxKind) -> bool {2733 match kind {2734 FLOAT | META_FORCE_ENUM => true,2735 _ => false,2736 }2737 }2738 fn cast(syntax: SyntaxToken) -> Option<Self> {2739 let res = match syntax.kind() {2740 FLOAT => Number {2741 syntax,2742 kind: NumberKind::Float,2743 },2744 META_FORCE_ENUM => Number {2745 syntax,2746 kind: NumberKind::MetaForceEnum,2747 },2748 _ => return None,2749 };2750 Some(res)2751 }2752 fn syntax(&self) -> &SyntaxToken {2753 &self.syntax2754 }2755}2756impl Number {2757 pub fn kind(&self) -> NumberKind {2758 self.kind2759 }2760}2761impl std::fmt::Display for Number {2762 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2763 std::fmt::Display::fmt(self.syntax(), f)2764 }2765}2766impl AstToken for ImportKind {2767 fn can_cast(kind: SyntaxKind) -> bool {2768 match kind {2769 IMPORTSTR_KW | IMPORTBIN_KW | IMPORT_KW => true,2770 _ => false,2771 }2772 }2773 fn cast(syntax: SyntaxToken) -> Option<Self> {2774 let res = match syntax.kind() {2775 IMPORTSTR_KW => ImportKind {2776 syntax,2777 kind: ImportKindKind::ImportstrKw,2778 },2779 IMPORTBIN_KW => ImportKind {2780 syntax,2781 kind: ImportKindKind::ImportbinKw,2782 },2783 IMPORT_KW => ImportKind {2784 syntax,2785 kind: ImportKindKind::ImportKw,2786 },2787 _ => return None,2788 };2789 Some(res)2790 }2791 fn syntax(&self) -> &SyntaxToken {2792 &self.syntax2793 }2794}2795impl ImportKind {2796 pub fn kind(&self) -> ImportKindKind {2797 self.kind2798 }2799}2800impl std::fmt::Display for ImportKind {2801 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2802 std::fmt::Display::fmt(self.syntax(), f)2803 }2804}2805impl AstToken for Visibility {2806 fn can_cast(kind: SyntaxKind) -> bool {2807 match kind {2808 COLONCOLONCOLON | COLONCOLON | COLON => true,2809 _ => false,2810 }2811 }2812 fn cast(syntax: SyntaxToken) -> Option<Self> {2813 let res = match syntax.kind() {2814 COLONCOLONCOLON => Visibility {2815 syntax,2816 kind: VisibilityKind::Coloncoloncolon,2817 },2818 COLONCOLON => Visibility {2819 syntax,2820 kind: VisibilityKind::Coloncolon,2821 },2822 COLON => Visibility {2823 syntax,2824 kind: VisibilityKind::Colon,2825 },2826 _ => return None,2827 };2828 Some(res)2829 }2830 fn syntax(&self) -> &SyntaxToken {2831 &self.syntax2832 }2833}2834impl Visibility {2835 pub fn kind(&self) -> VisibilityKind {2836 self.kind2837 }2838}2839impl std::fmt::Display for Visibility {2840 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2841 std::fmt::Display::fmt(self.syntax(), f)2842 }2843}2844impl std::fmt::Display for Expr {2845 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2846 std::fmt::Display::fmt(self.syntax(), f)2847 }2848}2849impl std::fmt::Display for ObjBody {2850 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2851 std::fmt::Display::fmt(self.syntax(), f)2852 }2853}2854impl std::fmt::Display for CompSpec {2855 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2856 std::fmt::Display::fmt(self.syntax(), f)2857 }2858}2859impl std::fmt::Display for Bind {2860 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2861 std::fmt::Display::fmt(self.syntax(), f)2862 }2863}2864impl std::fmt::Display for Member {2865 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2866 std::fmt::Display::fmt(self.syntax(), f)2867 }2868}2869impl std::fmt::Display for Field {2870 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2871 std::fmt::Display::fmt(self.syntax(), f)2872 }2873}2874impl std::fmt::Display for FieldName {2875 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2876 std::fmt::Display::fmt(self.syntax(), f)2877 }2878}2879impl std::fmt::Display for Destruct {2880 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2881 std::fmt::Display::fmt(self.syntax(), f)2882 }2883}2884impl std::fmt::Display for DestructArrayPart {2885 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2886 std::fmt::Display::fmt(self.syntax(), f)2887 }2888}2889impl std::fmt::Display for SourceFile {2890 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2891 std::fmt::Display::fmt(self.syntax(), f)2892 }2893}2894impl std::fmt::Display for ExprBinary {2895 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2896 std::fmt::Display::fmt(self.syntax(), f)2897 }2898}2899impl std::fmt::Display for LhsExpr {2900 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2901 std::fmt::Display::fmt(self.syntax(), f)2902 }2903}2904impl std::fmt::Display for ExprUnary {2905 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2906 std::fmt::Display::fmt(self.syntax(), f)2907 }2908}2909impl std::fmt::Display for ExprSlice {2910 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2911 std::fmt::Display::fmt(self.syntax(), f)2912 }2913}2914impl std::fmt::Display for SliceDesc {2915 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2916 std::fmt::Display::fmt(self.syntax(), f)2917 }2918}2919impl std::fmt::Display for ExprIndex {2920 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2921 std::fmt::Display::fmt(self.syntax(), f)2922 }2923}2924impl std::fmt::Display for Name {2925 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2926 std::fmt::Display::fmt(self.syntax(), f)2927 }2928}2929impl std::fmt::Display for ExprIndexExpr {2930 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2931 std::fmt::Display::fmt(self.syntax(), f)2932 }2933}2934impl std::fmt::Display for ExprApply {2935 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2936 std::fmt::Display::fmt(self.syntax(), f)2937 }2938}2939impl std::fmt::Display for ArgsDesc {2940 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2941 std::fmt::Display::fmt(self.syntax(), f)2942 }2943}2944impl std::fmt::Display for ExprObjExtend {2945 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2946 std::fmt::Display::fmt(self.syntax(), f)2947 }2948}2949impl std::fmt::Display for ExprParened {2950 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2951 std::fmt::Display::fmt(self.syntax(), f)2952 }2953}2954impl std::fmt::Display for ExprLiteral {2955 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2956 std::fmt::Display::fmt(self.syntax(), f)2957 }2958}2959impl std::fmt::Display for ExprIntrinsicThisFile {2960 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2961 std::fmt::Display::fmt(self.syntax(), f)2962 }2963}2964impl std::fmt::Display for ExprIntrinsicId {2965 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2966 std::fmt::Display::fmt(self.syntax(), f)2967 }2968}2969impl std::fmt::Display for ExprIntrinsic {2970 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2971 std::fmt::Display::fmt(self.syntax(), f)2972 }2973}2974impl std::fmt::Display for ExprString {2975 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2976 std::fmt::Display::fmt(self.syntax(), f)2977 }2978}2979impl std::fmt::Display for ExprNumber {2980 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2981 std::fmt::Display::fmt(self.syntax(), f)2982 }2983}2984impl std::fmt::Display for ExprArray {2985 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2986 std::fmt::Display::fmt(self.syntax(), f)2987 }2988}2989impl std::fmt::Display for ExprObject {2990 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2991 std::fmt::Display::fmt(self.syntax(), f)2992 }2993}2994impl std::fmt::Display for ExprArrayComp {2995 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2996 std::fmt::Display::fmt(self.syntax(), f)2997 }2998}2999impl std::fmt::Display for ExprImport {3000 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3001 std::fmt::Display::fmt(self.syntax(), f)3002 }3003}3004impl std::fmt::Display for ExprVar {3005 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3006 std::fmt::Display::fmt(self.syntax(), f)3007 }3008}3009impl std::fmt::Display for ExprLocal {3010 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3011 std::fmt::Display::fmt(self.syntax(), f)3012 }3013}3014impl std::fmt::Display for ExprIfThenElse {3015 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3016 std::fmt::Display::fmt(self.syntax(), f)3017 }3018}3019impl std::fmt::Display for TrueExpr {3020 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3021 std::fmt::Display::fmt(self.syntax(), f)3022 }3023}3024impl std::fmt::Display for FalseExpr {3025 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3026 std::fmt::Display::fmt(self.syntax(), f)3027 }3028}3029impl std::fmt::Display for ExprFunction {3030 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3031 std::fmt::Display::fmt(self.syntax(), f)3032 }3033}3034impl std::fmt::Display for ParamsDesc {3035 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3036 std::fmt::Display::fmt(self.syntax(), f)3037 }3038}3039impl std::fmt::Display for ExprAssert {3040 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3041 std::fmt::Display::fmt(self.syntax(), f)3042 }3043}3044impl std::fmt::Display for Assertion {3045 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3046 std::fmt::Display::fmt(self.syntax(), f)3047 }3048}3049impl std::fmt::Display for ExprError {3050 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3051 std::fmt::Display::fmt(self.syntax(), f)3052 }3053}3054impl std::fmt::Display for SliceDescEnd {3055 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3056 std::fmt::Display::fmt(self.syntax(), f)3057 }3058}3059impl std::fmt::Display for SliceDescStep {3060 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3061 std::fmt::Display::fmt(self.syntax(), f)3062 }3063}3064impl std::fmt::Display for Arg {3065 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3066 std::fmt::Display::fmt(self.syntax(), f)3067 }3068}3069impl std::fmt::Display for ObjBodyComp {3070 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3071 std::fmt::Display::fmt(self.syntax(), f)3072 }3073}3074impl std::fmt::Display for ObjLocalPostComma {3075 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3076 std::fmt::Display::fmt(self.syntax(), f)3077 }3078}3079impl std::fmt::Display for ObjLocalPreComma {3080 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3081 std::fmt::Display::fmt(self.syntax(), f)3082 }3083}3084impl std::fmt::Display for ObjBodyMemberList {3085 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3086 std::fmt::Display::fmt(self.syntax(), f)3087 }3088}3089impl std::fmt::Display for ObjLocal {3090 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3091 std::fmt::Display::fmt(self.syntax(), f)3092 }3093}3094impl std::fmt::Display for MemberBindStmt {3095 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3096 std::fmt::Display::fmt(self.syntax(), f)3097 }3098}3099impl std::fmt::Display for MemberAssertStmt {3100 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3101 std::fmt::Display::fmt(self.syntax(), f)3102 }3103}3104impl std::fmt::Display for MemberField {3105 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3106 std::fmt::Display::fmt(self.syntax(), f)3107 }3108}3109impl std::fmt::Display for FieldNormal {3110 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3111 std::fmt::Display::fmt(self.syntax(), f)3112 }3113}3114impl std::fmt::Display for FieldMethod {3115 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3116 std::fmt::Display::fmt(self.syntax(), f)3117 }3118}3119impl std::fmt::Display for FieldNameFixed {3120 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3121 std::fmt::Display::fmt(self.syntax(), f)3122 }3123}3124impl std::fmt::Display for FieldNameDynamic {3125 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3126 std::fmt::Display::fmt(self.syntax(), f)3127 }3128}3129impl std::fmt::Display for ForSpec {3130 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3131 std::fmt::Display::fmt(self.syntax(), f)3132 }3133}3134impl std::fmt::Display for IfSpec {3135 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3136 std::fmt::Display::fmt(self.syntax(), f)3137 }3138}3139impl std::fmt::Display for BindDestruct {3140 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3141 std::fmt::Display::fmt(self.syntax(), f)3142 }3143}3144impl std::fmt::Display for BindFunction {3145 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3146 std::fmt::Display::fmt(self.syntax(), f)3147 }3148}3149impl std::fmt::Display for Param {3150 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3151 std::fmt::Display::fmt(self.syntax(), f)3152 }3153}3154impl std::fmt::Display for DestructFull {3155 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3156 std::fmt::Display::fmt(self.syntax(), f)3157 }3158}3159impl std::fmt::Display for DestructSkip {3160 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3161 std::fmt::Display::fmt(self.syntax(), f)3162 }3163}3164impl std::fmt::Display for DestructArray {3165 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3166 std::fmt::Display::fmt(self.syntax(), f)3167 }3168}3169impl std::fmt::Display for DestructObject {3170 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3171 std::fmt::Display::fmt(self.syntax(), f)3172 }3173}3174impl std::fmt::Display for DestructObjectField {3175 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3176 std::fmt::Display::fmt(self.syntax(), f)3177 }3178}3179impl std::fmt::Display for DestructRest {3180 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3181 std::fmt::Display::fmt(self.syntax(), f)3182 }3183}3184impl std::fmt::Display for DestructArrayElement {3185 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3186 std::fmt::Display::fmt(self.syntax(), f)3187 }3188}