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