difftreelog
feat(rowan) alternative object comp syntax
in: master
10 files changed
crates/jrsonnet-formatter/src/lib.rsdiffbeforeafterboth--- a/crates/jrsonnet-formatter/src/lib.rs
+++ b/crates/jrsonnet-formatter/src/lib.rs
@@ -13,9 +13,9 @@
AstNode, AstToken as _, SyntaxToken,
nodes::{
Arg, ArgsDesc, Assertion, BinaryOperator, Bind, CompSpec, Destruct, DestructArrayPart,
- DestructRest, Expr, ExprArray, ExprBase, FieldName, ForSpec, IfSpec, ImportKind, Literal,
- Member, Name, Number, ObjBody, ObjLocal, ParamsDesc, SliceDesc, SourceFile, Stmt, Suffix,
- Text, TextKind, UnaryOperator, Visibility,
+ DestructRest, Expr, ExprArray, ExprBase, FieldName, ForObjSpec, ForSpec, IfSpec,
+ ImportKind, Literal, Member, Name, Number, ObjBody, ObjLocal, ParamsDesc, SliceDesc,
+ SourceFile, Stmt, Suffix, Text, TextKind, UnaryOperator, Visibility,
},
};
@@ -645,6 +645,11 @@
p!(out, str("for ") {self.bind()} str(" in ") {self.expr()});
}
}
+impl Printable for ForObjSpec {
+ fn print(&self, out: &mut PrintItems) {
+ p!(out, str("for [") {self.key()} str("]") {self.visibility()} str(" ") {self.value()} str(" in ") {self.expr()});
+ }
+}
impl Printable for IfSpec {
fn print(&self, out: &mut PrintItems) {
p!(out, str("if ") {self.expr()});
@@ -654,6 +659,7 @@
fn print(&self, out: &mut PrintItems) {
match self {
Self::ForSpec(f) => f.print(out),
+ Self::ForObjSpec(f) => f.print(out),
Self::IfSpec(i) => i.print(out),
}
}
crates/jrsonnet-rowan-parser/jsonnet.ungramdiffbeforeafterboth--- a/crates/jrsonnet-rowan-parser/jsonnet.ungram
+++ b/crates/jrsonnet-rowan-parser/jsonnet.ungram
@@ -246,11 +246,21 @@
bind:Destruct
'in'
Expr
+ForObjSpec =
+ 'for'
+ '['
+ key:Name
+ ']'
+ Visibility
+ value:Destruct
+ 'in'
+ Expr
IfSpec =
'if'
Expr
CompSpec =
ForSpec
+| ForObjSpec
| IfSpec
BindDestruct =
crates/jrsonnet-rowan-parser/src/generated/nodes.rsdiffbeforeafterboth1//! This is a generated file, please do not edit manually. Changes can be2//! made in codegeneration that lives in `xtask` top-level dir.34#![allow(non_snake_case, clippy::match_like_matches_macro)]5use crate::{6 SyntaxKind::{self, *},7 SyntaxNode, SyntaxToken, T,8 ast::{AstChildren, AstNode, AstToken, support},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::children(&self.syntax).next()18 }19}2021#[derive(Debug, Clone, PartialEq, Eq, Hash)]22pub struct Expr {23 pub(crate) syntax: SyntaxNode,24}25impl Expr {26 pub fn stmts(&self) -> AstChildren<Stmt> {27 support::children(&self.syntax)28 }29 pub fn expr_base(&self) -> Option<ExprBase> {30 support::children(&self.syntax).next()31 }32 pub fn suffixs(&self) -> AstChildren<Suffix> {33 support::children(&self.syntax)34 }35}3637#[derive(Debug, Clone, PartialEq, Eq, Hash)]38pub struct SuffixIndex {39 pub(crate) syntax: SyntaxNode,40}41impl SuffixIndex {42 pub fn question_mark_token(&self) -> Option<SyntaxToken> {43 support::token(&self.syntax, T![?])44 }45 pub fn dot_token(&self) -> Option<SyntaxToken> {46 support::token(&self.syntax, T![.])47 }48 pub fn index(&self) -> Option<Name> {49 support::children(&self.syntax).next()50 }51}5253#[derive(Debug, Clone, PartialEq, Eq, Hash)]54pub struct Name {55 pub(crate) syntax: SyntaxNode,56}57impl Name {58 pub fn ident_lit(&self) -> Option<SyntaxToken> {59 support::token(&self.syntax, IDENT)60 }61}6263#[derive(Debug, Clone, PartialEq, Eq, Hash)]64pub struct SuffixIndexExpr {65 pub(crate) syntax: SyntaxNode,66}67impl SuffixIndexExpr {68 pub fn question_mark_token(&self) -> Option<SyntaxToken> {69 support::token(&self.syntax, T![?])70 }71 pub fn dot_token(&self) -> Option<SyntaxToken> {72 support::token(&self.syntax, T![.])73 }74 pub fn l_brack_token(&self) -> Option<SyntaxToken> {75 support::token(&self.syntax, T!['['])76 }77 pub fn index(&self) -> Option<Expr> {78 support::children(&self.syntax).next()79 }80 pub fn r_brack_token(&self) -> Option<SyntaxToken> {81 support::token(&self.syntax, T![']'])82 }83}8485#[derive(Debug, Clone, PartialEq, Eq, Hash)]86pub struct SuffixSlice {87 pub(crate) syntax: SyntaxNode,88}89impl SuffixSlice {90 pub fn slice_desc(&self) -> Option<SliceDesc> {91 support::children(&self.syntax).next()92 }93}9495#[derive(Debug, Clone, PartialEq, Eq, Hash)]96pub struct SliceDesc {97 pub(crate) syntax: SyntaxNode,98}99impl SliceDesc {100 pub fn l_brack_token(&self) -> Option<SyntaxToken> {101 support::token(&self.syntax, T!['['])102 }103 pub fn from(&self) -> Option<Expr> {104 support::children(&self.syntax).next()105 }106 pub fn colon_token(&self) -> Option<SyntaxToken> {107 support::token(&self.syntax, T![:])108 }109 pub fn end(&self) -> Option<SliceDescEnd> {110 support::children(&self.syntax).next()111 }112 pub fn step(&self) -> Option<SliceDescStep> {113 support::children(&self.syntax).next()114 }115 pub fn r_brack_token(&self) -> Option<SyntaxToken> {116 support::token(&self.syntax, T![']'])117 }118}119120#[derive(Debug, Clone, PartialEq, Eq, Hash)]121pub struct SuffixApply {122 pub(crate) syntax: SyntaxNode,123}124impl SuffixApply {125 pub fn args_desc(&self) -> Option<ArgsDesc> {126 support::children(&self.syntax).next()127 }128 pub fn tailstrict_kw_token(&self) -> Option<SyntaxToken> {129 support::token(&self.syntax, T![tailstrict])130 }131}132133#[derive(Debug, Clone, PartialEq, Eq, Hash)]134pub struct ArgsDesc {135 pub(crate) syntax: SyntaxNode,136}137impl ArgsDesc {138 pub fn l_paren_token(&self) -> Option<SyntaxToken> {139 support::token(&self.syntax, T!['('])140 }141 pub fn args(&self) -> AstChildren<Arg> {142 support::children(&self.syntax)143 }144 pub fn r_paren_token(&self) -> Option<SyntaxToken> {145 support::token(&self.syntax, T![')'])146 }147}148149#[derive(Debug, Clone, PartialEq, Eq, Hash)]150pub struct StmtLocal {151 pub(crate) syntax: SyntaxNode,152}153impl StmtLocal {154 pub fn local_kw_token(&self) -> Option<SyntaxToken> {155 support::token(&self.syntax, T![local])156 }157 pub fn binds(&self) -> AstChildren<Bind> {158 support::children(&self.syntax)159 }160 pub fn semi_token(&self) -> Option<SyntaxToken> {161 support::token(&self.syntax, T![;])162 }163}164165#[derive(Debug, Clone, PartialEq, Eq, Hash)]166pub struct StmtAssert {167 pub(crate) syntax: SyntaxNode,168}169impl StmtAssert {170 pub fn assertion(&self) -> Option<Assertion> {171 support::children(&self.syntax).next()172 }173 pub fn semi_token(&self) -> Option<SyntaxToken> {174 support::token(&self.syntax, T![;])175 }176}177178#[derive(Debug, Clone, PartialEq, Eq, Hash)]179pub struct Assertion {180 pub(crate) syntax: SyntaxNode,181}182impl Assertion {183 pub fn assert_kw_token(&self) -> Option<SyntaxToken> {184 support::token(&self.syntax, T![assert])185 }186 pub fn condition(&self) -> Option<Expr> {187 support::children(&self.syntax).next()188 }189 pub fn colon_token(&self) -> Option<SyntaxToken> {190 support::token(&self.syntax, T![:])191 }192 pub fn message(&self) -> Option<Expr> {193 support::children(&self.syntax).nth(1usize)194 }195}196197#[derive(Debug, Clone, PartialEq, Eq, Hash)]198pub struct ExprBinary {199 pub(crate) syntax: SyntaxNode,200}201impl ExprBinary {202 pub fn lhs(&self) -> Option<Expr> {203 support::children(&self.syntax).next()204 }205 pub fn binary_operator(&self) -> Option<BinaryOperator> {206 support::token_child(&self.syntax)207 }208 pub fn rhs(&self) -> Option<Expr> {209 support::children(&self.syntax).nth(1usize)210 }211}212213#[derive(Debug, Clone, PartialEq, Eq, Hash)]214pub struct ExprUnary {215 pub(crate) syntax: SyntaxNode,216}217impl ExprUnary {218 pub fn unary_operator(&self) -> Option<UnaryOperator> {219 support::token_child(&self.syntax)220 }221 pub fn rhs(&self) -> Option<Expr> {222 support::children(&self.syntax).next()223 }224}225226#[derive(Debug, Clone, PartialEq, Eq, Hash)]227pub struct ExprObjExtend {228 pub(crate) syntax: SyntaxNode,229}230impl ExprObjExtend {231 pub fn lhs(&self) -> Option<Expr> {232 support::children(&self.syntax).next()233 }234 pub fn rhs(&self) -> Option<Expr> {235 support::children(&self.syntax).nth(1usize)236 }237}238239#[derive(Debug, Clone, PartialEq, Eq, Hash)]240pub struct ExprParened {241 pub(crate) syntax: SyntaxNode,242}243impl ExprParened {244 pub fn l_paren_token(&self) -> Option<SyntaxToken> {245 support::token(&self.syntax, T!['('])246 }247 pub fn expr(&self) -> Option<Expr> {248 support::children(&self.syntax).next()249 }250 pub fn r_paren_token(&self) -> Option<SyntaxToken> {251 support::token(&self.syntax, T![')'])252 }253}254255#[derive(Debug, Clone, PartialEq, Eq, Hash)]256pub struct ExprLiteral {257 pub(crate) syntax: SyntaxNode,258}259impl ExprLiteral {260 pub fn literal(&self) -> Option<Literal> {261 support::token_child(&self.syntax)262 }263}264265#[derive(Debug, Clone, PartialEq, Eq, Hash)]266pub struct ExprString {267 pub(crate) syntax: SyntaxNode,268}269impl ExprString {270 pub fn text(&self) -> Option<Text> {271 support::token_child(&self.syntax)272 }273}274275#[derive(Debug, Clone, PartialEq, Eq, Hash)]276pub struct ExprNumber {277 pub(crate) syntax: SyntaxNode,278}279impl ExprNumber {280 pub fn number(&self) -> Option<Number> {281 support::token_child(&self.syntax)282 }283}284285#[derive(Debug, Clone, PartialEq, Eq, Hash)]286pub struct ExprArray {287 pub(crate) syntax: SyntaxNode,288}289impl ExprArray {290 pub fn l_brack_token(&self) -> Option<SyntaxToken> {291 support::token(&self.syntax, T!['['])292 }293 pub fn exprs(&self) -> AstChildren<Expr> {294 support::children(&self.syntax)295 }296 pub fn r_brack_token(&self) -> Option<SyntaxToken> {297 support::token(&self.syntax, T![']'])298 }299}300301#[derive(Debug, Clone, PartialEq, Eq, Hash)]302pub struct ExprObject {303 pub(crate) syntax: SyntaxNode,304}305impl ExprObject {306 pub fn obj_body(&self) -> Option<ObjBody> {307 support::children(&self.syntax).next()308 }309}310311#[derive(Debug, Clone, PartialEq, Eq, Hash)]312pub struct ExprArrayComp {313 pub(crate) syntax: SyntaxNode,314}315impl ExprArrayComp {316 pub fn l_brack_token(&self) -> Option<SyntaxToken> {317 support::token(&self.syntax, T!['['])318 }319 pub fn expr(&self) -> Option<Expr> {320 support::children(&self.syntax).next()321 }322 pub fn comma_token(&self) -> Option<SyntaxToken> {323 support::token(&self.syntax, T![,])324 }325 pub fn comp_specs(&self) -> AstChildren<CompSpec> {326 support::children(&self.syntax)327 }328 pub fn r_brack_token(&self) -> Option<SyntaxToken> {329 support::token(&self.syntax, T![']'])330 }331}332333#[derive(Debug, Clone, PartialEq, Eq, Hash)]334pub struct ExprImport {335 pub(crate) syntax: SyntaxNode,336}337impl ExprImport {338 pub fn import_kind(&self) -> Option<ImportKind> {339 support::token_child(&self.syntax)340 }341 pub fn text(&self) -> Option<Text> {342 support::token_child(&self.syntax)343 }344}345346#[derive(Debug, Clone, PartialEq, Eq, Hash)]347pub struct ExprVar {348 pub(crate) syntax: SyntaxNode,349}350impl ExprVar {351 pub fn name(&self) -> Option<Name> {352 support::children(&self.syntax).next()353 }354}355356#[derive(Debug, Clone, PartialEq, Eq, Hash)]357pub struct ExprIfThenElse {358 pub(crate) syntax: SyntaxNode,359}360impl ExprIfThenElse {361 pub fn if_kw_token(&self) -> Option<SyntaxToken> {362 support::token(&self.syntax, T![if])363 }364 pub fn cond(&self) -> Option<Expr> {365 support::children(&self.syntax).next()366 }367 pub fn then_kw_token(&self) -> Option<SyntaxToken> {368 support::token(&self.syntax, T![then])369 }370 pub fn then(&self) -> Option<TrueExpr> {371 support::children(&self.syntax).next()372 }373 pub fn else_kw_token(&self) -> Option<SyntaxToken> {374 support::token(&self.syntax, T![else])375 }376 pub fn else_(&self) -> Option<FalseExpr> {377 support::children(&self.syntax).next()378 }379}380381#[derive(Debug, Clone, PartialEq, Eq, Hash)]382pub struct TrueExpr {383 pub(crate) syntax: SyntaxNode,384}385impl TrueExpr {386 pub fn expr(&self) -> Option<Expr> {387 support::children(&self.syntax).next()388 }389}390391#[derive(Debug, Clone, PartialEq, Eq, Hash)]392pub struct FalseExpr {393 pub(crate) syntax: SyntaxNode,394}395impl FalseExpr {396 pub fn expr(&self) -> Option<Expr> {397 support::children(&self.syntax).next()398 }399}400401#[derive(Debug, Clone, PartialEq, Eq, Hash)]402pub struct ExprFunction {403 pub(crate) syntax: SyntaxNode,404}405impl ExprFunction {406 pub fn function_kw_token(&self) -> Option<SyntaxToken> {407 support::token(&self.syntax, T![function])408 }409 pub fn l_paren_token(&self) -> Option<SyntaxToken> {410 support::token(&self.syntax, T!['('])411 }412 pub fn params_desc(&self) -> Option<ParamsDesc> {413 support::children(&self.syntax).next()414 }415 pub fn r_paren_token(&self) -> Option<SyntaxToken> {416 support::token(&self.syntax, T![')'])417 }418 pub fn expr(&self) -> Option<Expr> {419 support::children(&self.syntax).next()420 }421}422423#[derive(Debug, Clone, PartialEq, Eq, Hash)]424pub struct ParamsDesc {425 pub(crate) syntax: SyntaxNode,426}427impl ParamsDesc {428 pub fn l_paren_token(&self) -> Option<SyntaxToken> {429 support::token(&self.syntax, T!['('])430 }431 pub fn params(&self) -> AstChildren<Param> {432 support::children(&self.syntax)433 }434 pub fn r_paren_token(&self) -> Option<SyntaxToken> {435 support::token(&self.syntax, T![')'])436 }437}438439#[derive(Debug, Clone, PartialEq, Eq, Hash)]440pub struct ExprError {441 pub(crate) syntax: SyntaxNode,442}443impl ExprError {444 pub fn error_kw_token(&self) -> Option<SyntaxToken> {445 support::token(&self.syntax, T![error])446 }447 pub fn expr(&self) -> Option<Expr> {448 support::children(&self.syntax).next()449 }450}451452#[derive(Debug, Clone, PartialEq, Eq, Hash)]453pub struct SliceDescEnd {454 pub(crate) syntax: SyntaxNode,455}456impl SliceDescEnd {457 pub fn expr(&self) -> Option<Expr> {458 support::children(&self.syntax).next()459 }460}461462#[derive(Debug, Clone, PartialEq, Eq, Hash)]463pub struct SliceDescStep {464 pub(crate) syntax: SyntaxNode,465}466impl SliceDescStep {467 pub fn expr(&self) -> Option<Expr> {468 support::children(&self.syntax).next()469 }470}471472#[derive(Debug, Clone, PartialEq, Eq, Hash)]473pub struct Arg {474 pub(crate) syntax: SyntaxNode,475}476impl Arg {477 pub fn name(&self) -> Option<Name> {478 support::children(&self.syntax).next()479 }480 pub fn assign_token(&self) -> Option<SyntaxToken> {481 support::token(&self.syntax, T![=])482 }483 pub fn expr(&self) -> Option<Expr> {484 support::children(&self.syntax).next()485 }486}487488#[derive(Debug, Clone, PartialEq, Eq, Hash)]489pub struct ObjBodyComp {490 pub(crate) syntax: SyntaxNode,491}492impl ObjBodyComp {493 pub fn l_brace_token(&self) -> Option<SyntaxToken> {494 support::token(&self.syntax, T!['{'])495 }496 pub fn member_comps(&self) -> AstChildren<MemberComp> {497 support::children(&self.syntax)498 }499 pub fn comp_specs(&self) -> AstChildren<CompSpec> {500 support::children(&self.syntax)501 }502 pub fn r_brace_token(&self) -> Option<SyntaxToken> {503 support::token(&self.syntax, T!['}'])504 }505}506507#[derive(Debug, Clone, PartialEq, Eq, Hash)]508pub struct ObjBodyMemberList {509 pub(crate) syntax: SyntaxNode,510}511impl ObjBodyMemberList {512 pub fn l_brace_token(&self) -> Option<SyntaxToken> {513 support::token(&self.syntax, T!['{'])514 }515 pub fn members(&self) -> AstChildren<Member> {516 support::children(&self.syntax)517 }518 pub fn r_brace_token(&self) -> Option<SyntaxToken> {519 support::token(&self.syntax, T!['}'])520 }521}522523#[derive(Debug, Clone, PartialEq, Eq, Hash)]524pub struct MemberBindStmt {525 pub(crate) syntax: SyntaxNode,526}527impl MemberBindStmt {528 pub fn obj_local(&self) -> Option<ObjLocal> {529 support::children(&self.syntax).next()530 }531}532533#[derive(Debug, Clone, PartialEq, Eq, Hash)]534pub struct ObjLocal {535 pub(crate) syntax: SyntaxNode,536}537impl ObjLocal {538 pub fn local_kw_token(&self) -> Option<SyntaxToken> {539 support::token(&self.syntax, T![local])540 }541 pub fn bind(&self) -> Option<Bind> {542 support::children(&self.syntax).next()543 }544}545546#[derive(Debug, Clone, PartialEq, Eq, Hash)]547pub struct MemberAssertStmt {548 pub(crate) syntax: SyntaxNode,549}550impl MemberAssertStmt {551 pub fn assertion(&self) -> Option<Assertion> {552 support::children(&self.syntax).next()553 }554}555556#[derive(Debug, Clone, PartialEq, Eq, Hash)]557pub struct MemberFieldNormal {558 pub(crate) syntax: SyntaxNode,559}560impl MemberFieldNormal {561 pub fn field_name(&self) -> Option<FieldName> {562 support::children(&self.syntax).next()563 }564 pub fn plus_token(&self) -> Option<SyntaxToken> {565 support::token(&self.syntax, T![+])566 }567 pub fn visibility(&self) -> Option<Visibility> {568 support::children(&self.syntax).next()569 }570 pub fn expr(&self) -> Option<Expr> {571 support::children(&self.syntax).next()572 }573}574575#[derive(Debug, Clone, PartialEq, Eq, Hash)]576pub struct Visibility {577 pub(crate) syntax: SyntaxNode,578}579impl Visibility {580 pub fn colon_token(&self) -> Option<SyntaxToken> {581 support::token(&self.syntax, T![:])582 }583}584585#[derive(Debug, Clone, PartialEq, Eq, Hash)]586pub struct MemberFieldMethod {587 pub(crate) syntax: SyntaxNode,588}589impl MemberFieldMethod {590 pub fn field_name(&self) -> Option<FieldName> {591 support::children(&self.syntax).next()592 }593 pub fn params_desc(&self) -> Option<ParamsDesc> {594 support::children(&self.syntax).next()595 }596 pub fn visibility(&self) -> Option<Visibility> {597 support::children(&self.syntax).next()598 }599 pub fn expr(&self) -> Option<Expr> {600 support::children(&self.syntax).next()601 }602}603604#[derive(Debug, Clone, PartialEq, Eq, Hash)]605pub struct FieldNameFixed {606 pub(crate) syntax: SyntaxNode,607}608impl FieldNameFixed {609 pub fn id(&self) -> Option<Name> {610 support::children(&self.syntax).next()611 }612 pub fn text(&self) -> Option<Text> {613 support::token_child(&self.syntax)614 }615}616617#[derive(Debug, Clone, PartialEq, Eq, Hash)]618pub struct FieldNameDynamic {619 pub(crate) syntax: SyntaxNode,620}621impl FieldNameDynamic {622 pub fn l_brack_token(&self) -> Option<SyntaxToken> {623 support::token(&self.syntax, T!['['])624 }625 pub fn expr(&self) -> Option<Expr> {626 support::children(&self.syntax).next()627 }628 pub fn r_brack_token(&self) -> Option<SyntaxToken> {629 support::token(&self.syntax, T![']'])630 }631}632633#[derive(Debug, Clone, PartialEq, Eq, Hash)]634pub struct ForSpec {635 pub(crate) syntax: SyntaxNode,636}637impl ForSpec {638 pub fn for_kw_token(&self) -> Option<SyntaxToken> {639 support::token(&self.syntax, T![for])640 }641 pub fn bind(&self) -> Option<Destruct> {642 support::children(&self.syntax).next()643 }644 pub fn in_kw_token(&self) -> Option<SyntaxToken> {645 support::token(&self.syntax, T![in])646 }647 pub fn expr(&self) -> Option<Expr> {648 support::children(&self.syntax).next()649 }650}651652#[derive(Debug, Clone, PartialEq, Eq, Hash)]653pub struct IfSpec {654 pub(crate) syntax: SyntaxNode,655}656impl IfSpec {657 pub fn if_kw_token(&self) -> Option<SyntaxToken> {658 support::token(&self.syntax, T![if])659 }660 pub fn expr(&self) -> Option<Expr> {661 support::children(&self.syntax).next()662 }663}664665#[derive(Debug, Clone, PartialEq, Eq, Hash)]666pub struct BindDestruct {667 pub(crate) syntax: SyntaxNode,668}669impl BindDestruct {670 pub fn into(&self) -> Option<Destruct> {671 support::children(&self.syntax).next()672 }673 pub fn assign_token(&self) -> Option<SyntaxToken> {674 support::token(&self.syntax, T![=])675 }676 pub fn value(&self) -> Option<Expr> {677 support::children(&self.syntax).next()678 }679}680681#[derive(Debug, Clone, PartialEq, Eq, Hash)]682pub struct BindFunction {683 pub(crate) syntax: SyntaxNode,684}685impl BindFunction {686 pub fn name(&self) -> Option<Name> {687 support::children(&self.syntax).next()688 }689 pub fn params(&self) -> Option<ParamsDesc> {690 support::children(&self.syntax).next()691 }692 pub fn assign_token(&self) -> Option<SyntaxToken> {693 support::token(&self.syntax, T![=])694 }695 pub fn value(&self) -> Option<Expr> {696 support::children(&self.syntax).next()697 }698}699700#[derive(Debug, Clone, PartialEq, Eq, Hash)]701pub struct Param {702 pub(crate) syntax: SyntaxNode,703}704impl Param {705 pub fn destruct(&self) -> Option<Destruct> {706 support::children(&self.syntax).next()707 }708 pub fn assign_token(&self) -> Option<SyntaxToken> {709 support::token(&self.syntax, T![=])710 }711 pub fn expr(&self) -> Option<Expr> {712 support::children(&self.syntax).next()713 }714}715716#[derive(Debug, Clone, PartialEq, Eq, Hash)]717pub struct DestructFull {718 pub(crate) syntax: SyntaxNode,719}720impl DestructFull {721 pub fn name(&self) -> Option<Name> {722 support::children(&self.syntax).next()723 }724}725726#[derive(Debug, Clone, PartialEq, Eq, Hash)]727pub struct DestructSkip {728 pub(crate) syntax: SyntaxNode,729}730impl DestructSkip {731 pub fn question_mark_token(&self) -> Option<SyntaxToken> {732 support::token(&self.syntax, T![?])733 }734}735736#[derive(Debug, Clone, PartialEq, Eq, Hash)]737pub struct DestructArray {738 pub(crate) syntax: SyntaxNode,739}740impl DestructArray {741 pub fn l_brack_token(&self) -> Option<SyntaxToken> {742 support::token(&self.syntax, T!['['])743 }744 pub fn destruct_array_parts(&self) -> AstChildren<DestructArrayPart> {745 support::children(&self.syntax)746 }747 pub fn r_brack_token(&self) -> Option<SyntaxToken> {748 support::token(&self.syntax, T![']'])749 }750}751752#[derive(Debug, Clone, PartialEq, Eq, Hash)]753pub struct DestructObject {754 pub(crate) syntax: SyntaxNode,755}756impl DestructObject {757 pub fn l_brace_token(&self) -> Option<SyntaxToken> {758 support::token(&self.syntax, T!['{'])759 }760 pub fn destruct_object_fields(&self) -> AstChildren<DestructObjectField> {761 support::children(&self.syntax)762 }763 pub fn destruct_rest(&self) -> Option<DestructRest> {764 support::children(&self.syntax).next()765 }766 pub fn comma_token(&self) -> Option<SyntaxToken> {767 support::token(&self.syntax, T![,])768 }769 pub fn r_brace_token(&self) -> Option<SyntaxToken> {770 support::token(&self.syntax, T!['}'])771 }772}773774#[derive(Debug, Clone, PartialEq, Eq, Hash)]775pub struct DestructObjectField {776 pub(crate) syntax: SyntaxNode,777}778impl DestructObjectField {779 pub fn field(&self) -> Option<Name> {780 support::children(&self.syntax).next()781 }782 pub fn colon_token(&self) -> Option<SyntaxToken> {783 support::token(&self.syntax, T![:])784 }785 pub fn destruct(&self) -> Option<Destruct> {786 support::children(&self.syntax).next()787 }788 pub fn assign_token(&self) -> Option<SyntaxToken> {789 support::token(&self.syntax, T![=])790 }791 pub fn expr(&self) -> Option<Expr> {792 support::children(&self.syntax).next()793 }794}795796#[derive(Debug, Clone, PartialEq, Eq, Hash)]797pub struct DestructRest {798 pub(crate) syntax: SyntaxNode,799}800impl DestructRest {801 pub fn dotdotdot_token(&self) -> Option<SyntaxToken> {802 support::token(&self.syntax, T![...])803 }804 pub fn into(&self) -> Option<Name> {805 support::children(&self.syntax).next()806 }807}808809#[derive(Debug, Clone, PartialEq, Eq, Hash)]810pub struct DestructArrayElement {811 pub(crate) syntax: SyntaxNode,812}813impl DestructArrayElement {814 pub fn destruct(&self) -> Option<Destruct> {815 support::children(&self.syntax).next()816 }817}818819#[derive(Debug, Clone, PartialEq, Eq, Hash)]820pub enum Suffix {821 SuffixIndex(SuffixIndex),822 SuffixIndexExpr(SuffixIndexExpr),823 SuffixSlice(SuffixSlice),824 SuffixApply(SuffixApply),825}826827#[derive(Debug, Clone, PartialEq, Eq, Hash)]828pub enum Bind {829 BindDestruct(BindDestruct),830 BindFunction(BindFunction),831}832833#[derive(Debug, Clone, PartialEq, Eq, Hash)]834pub enum Stmt {835 StmtLocal(StmtLocal),836 StmtAssert(StmtAssert),837}838839#[derive(Debug, Clone, PartialEq, Eq, Hash)]840pub enum ObjBody {841 ObjBodyComp(ObjBodyComp),842 ObjBodyMemberList(ObjBodyMemberList),843}844845#[derive(Debug, Clone, PartialEq, Eq, Hash)]846pub enum CompSpec {847 ForSpec(ForSpec),848 IfSpec(IfSpec),849}850851#[derive(Debug, Clone, PartialEq, Eq, Hash)]852pub enum ExprBase {853 ExprBinary(ExprBinary),854 ExprUnary(ExprUnary),855 ExprObjExtend(ExprObjExtend),856 ExprParened(ExprParened),857 ExprString(ExprString),858 ExprNumber(ExprNumber),859 ExprLiteral(ExprLiteral),860 ExprArray(ExprArray),861 ExprObject(ExprObject),862 ExprArrayComp(ExprArrayComp),863 ExprImport(ExprImport),864 ExprVar(ExprVar),865 ExprIfThenElse(ExprIfThenElse),866 ExprFunction(ExprFunction),867 ExprError(ExprError),868}869870#[derive(Debug, Clone, PartialEq, Eq, Hash)]871pub enum MemberComp {872 MemberBindStmt(MemberBindStmt),873 MemberFieldNormal(MemberFieldNormal),874 MemberFieldMethod(MemberFieldMethod),875}876877#[derive(Debug, Clone, PartialEq, Eq, Hash)]878pub enum Member {879 MemberBindStmt(MemberBindStmt),880 MemberAssertStmt(MemberAssertStmt),881 MemberFieldNormal(MemberFieldNormal),882 MemberFieldMethod(MemberFieldMethod),883}884885#[derive(Debug, Clone, PartialEq, Eq, Hash)]886pub enum FieldName {887 FieldNameFixed(FieldNameFixed),888 FieldNameDynamic(FieldNameDynamic),889}890891#[derive(Debug, Clone, PartialEq, Eq, Hash)]892pub enum Destruct {893 DestructFull(DestructFull),894 DestructSkip(DestructSkip),895 DestructArray(DestructArray),896 DestructObject(DestructObject),897}898899#[derive(Debug, Clone, PartialEq, Eq, Hash)]900pub enum DestructArrayPart {901 DestructArrayElement(DestructArrayElement),902 DestructRest(DestructRest),903}904905#[derive(Debug, Clone, PartialEq, Eq, Hash)]906pub struct BinaryOperator {907 syntax: SyntaxToken,908 kind: BinaryOperatorKind,909}910911#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]912pub enum BinaryOperatorKind {913 Or,914 NullCoaelse,915 And,916 BitOr,917 BitXor,918 BitAnd,919 Eq,920 Ne,921 Lt,922 Gt,923 Le,924 Ge,925 InKw,926 Lhs,927 Rhs,928 Plus,929 Minus,930 Mul,931 Div,932 Modulo,933 MetaObjectApply,934 ErrorNoOperator,935}936937#[derive(Debug, Clone, PartialEq, Eq, Hash)]938pub struct UnaryOperator {939 syntax: SyntaxToken,940 kind: UnaryOperatorKind,941}942943#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]944pub enum UnaryOperatorKind {945 Minus,946 Not,947 BitNot,948}949950#[derive(Debug, Clone, PartialEq, Eq, Hash)]951pub struct Literal {952 syntax: SyntaxToken,953 kind: LiteralKind,954}955956#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]957pub enum LiteralKind {958 NullKw,959 TrueKw,960 FalseKw,961 SelfKw,962 Dollar,963 SuperKw,964}965966#[derive(Debug, Clone, PartialEq, Eq, Hash)]967pub struct Text {968 syntax: SyntaxToken,969 kind: TextKind,970}971972#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]973pub enum TextKind {974 StringDouble,975 ErrorStringDoubleUnterminated,976 StringSingle,977 ErrorStringSingleUnterminated,978 StringDoubleVerbatim,979 ErrorStringDoubleVerbatimUnterminated,980 StringSingleVerbatim,981 ErrorStringSingleVerbatimUnterminated,982 ErrorStringVerbatimMissingQuotes,983 StringBlock,984 ErrorStringBlockUnexpectedEnd,985 ErrorStringBlockMissingNewLine,986 ErrorStringBlockMissingTermination,987 ErrorStringBlockMissingIndent,988}989990#[derive(Debug, Clone, PartialEq, Eq, Hash)]991pub struct Number {992 syntax: SyntaxToken,993 kind: NumberKind,994}995996#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]997pub enum NumberKind {998 Float,999 ErrorFloatJunkAfterPoint,1000 ErrorFloatJunkAfterExponent,1001 ErrorFloatJunkAfterExponentSign,1002}10031004#[derive(Debug, Clone, PartialEq, Eq, Hash)]1005pub struct ImportKind {1006 syntax: SyntaxToken,1007 kind: ImportKindKind,1008}10091010#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]1011pub enum ImportKindKind {1012 ImportstrKw,1013 ImportbinKw,1014 ImportKw,1015}10161017#[derive(Debug, Clone, PartialEq, Eq, Hash)]1018pub struct Trivia {1019 syntax: SyntaxToken,1020 kind: TriviaKind,1021}10221023#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]1024pub enum TriviaKind {1025 Whitespace,1026 MultiLineComment,1027 ErrorCommentTooShort,1028 ErrorCommentUnterminated,1029 SingleLineHashComment,1030 SingleLineSlashComment,1031}10321033#[derive(Debug, Clone, PartialEq, Eq, Hash)]1034pub struct CustomError {1035 syntax: SyntaxToken,1036 kind: CustomErrorKind,1037}10381039#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]1040pub enum CustomErrorKind {1041 ErrorMissingToken,1042 ErrorUnexpectedToken,1043 ErrorCustom,1044}1045impl AstNode for SourceFile {1046 fn can_cast(kind: SyntaxKind) -> bool {1047 kind == SOURCE_FILE1048 }1049 fn cast(syntax: SyntaxNode) -> Option<Self> {1050 if Self::can_cast(syntax.kind()) {1051 Some(Self { syntax })1052 } else {1053 None1054 }1055 }1056 fn syntax(&self) -> &SyntaxNode {1057 &self.syntax1058 }1059}1060impl AstNode for Expr {1061 fn can_cast(kind: SyntaxKind) -> bool {1062 kind == EXPR1063 }1064 fn cast(syntax: SyntaxNode) -> Option<Self> {1065 if Self::can_cast(syntax.kind()) {1066 Some(Self { syntax })1067 } else {1068 None1069 }1070 }1071 fn syntax(&self) -> &SyntaxNode {1072 &self.syntax1073 }1074}1075impl AstNode for SuffixIndex {1076 fn can_cast(kind: SyntaxKind) -> bool {1077 kind == SUFFIX_INDEX1078 }1079 fn cast(syntax: SyntaxNode) -> Option<Self> {1080 if Self::can_cast(syntax.kind()) {1081 Some(Self { syntax })1082 } else {1083 None1084 }1085 }1086 fn syntax(&self) -> &SyntaxNode {1087 &self.syntax1088 }1089}1090impl AstNode for Name {1091 fn can_cast(kind: SyntaxKind) -> bool {1092 kind == NAME1093 }1094 fn cast(syntax: SyntaxNode) -> Option<Self> {1095 if Self::can_cast(syntax.kind()) {1096 Some(Self { syntax })1097 } else {1098 None1099 }1100 }1101 fn syntax(&self) -> &SyntaxNode {1102 &self.syntax1103 }1104}1105impl AstNode for SuffixIndexExpr {1106 fn can_cast(kind: SyntaxKind) -> bool {1107 kind == SUFFIX_INDEX_EXPR1108 }1109 fn cast(syntax: SyntaxNode) -> Option<Self> {1110 if Self::can_cast(syntax.kind()) {1111 Some(Self { syntax })1112 } else {1113 None1114 }1115 }1116 fn syntax(&self) -> &SyntaxNode {1117 &self.syntax1118 }1119}1120impl AstNode for SuffixSlice {1121 fn can_cast(kind: SyntaxKind) -> bool {1122 kind == SUFFIX_SLICE1123 }1124 fn cast(syntax: SyntaxNode) -> Option<Self> {1125 if Self::can_cast(syntax.kind()) {1126 Some(Self { syntax })1127 } else {1128 None1129 }1130 }1131 fn syntax(&self) -> &SyntaxNode {1132 &self.syntax1133 }1134}1135impl AstNode for SliceDesc {1136 fn can_cast(kind: SyntaxKind) -> bool {1137 kind == SLICE_DESC1138 }1139 fn cast(syntax: SyntaxNode) -> Option<Self> {1140 if Self::can_cast(syntax.kind()) {1141 Some(Self { syntax })1142 } else {1143 None1144 }1145 }1146 fn syntax(&self) -> &SyntaxNode {1147 &self.syntax1148 }1149}1150impl AstNode for SuffixApply {1151 fn can_cast(kind: SyntaxKind) -> bool {1152 kind == SUFFIX_APPLY1153 }1154 fn cast(syntax: SyntaxNode) -> Option<Self> {1155 if Self::can_cast(syntax.kind()) {1156 Some(Self { syntax })1157 } else {1158 None1159 }1160 }1161 fn syntax(&self) -> &SyntaxNode {1162 &self.syntax1163 }1164}1165impl AstNode for ArgsDesc {1166 fn can_cast(kind: SyntaxKind) -> bool {1167 kind == ARGS_DESC1168 }1169 fn cast(syntax: SyntaxNode) -> Option<Self> {1170 if Self::can_cast(syntax.kind()) {1171 Some(Self { syntax })1172 } else {1173 None1174 }1175 }1176 fn syntax(&self) -> &SyntaxNode {1177 &self.syntax1178 }1179}1180impl AstNode for StmtLocal {1181 fn can_cast(kind: SyntaxKind) -> bool {1182 kind == STMT_LOCAL1183 }1184 fn cast(syntax: SyntaxNode) -> Option<Self> {1185 if Self::can_cast(syntax.kind()) {1186 Some(Self { syntax })1187 } else {1188 None1189 }1190 }1191 fn syntax(&self) -> &SyntaxNode {1192 &self.syntax1193 }1194}1195impl AstNode for StmtAssert {1196 fn can_cast(kind: SyntaxKind) -> bool {1197 kind == STMT_ASSERT1198 }1199 fn cast(syntax: SyntaxNode) -> Option<Self> {1200 if Self::can_cast(syntax.kind()) {1201 Some(Self { syntax })1202 } else {1203 None1204 }1205 }1206 fn syntax(&self) -> &SyntaxNode {1207 &self.syntax1208 }1209}1210impl AstNode for Assertion {1211 fn can_cast(kind: SyntaxKind) -> bool {1212 kind == ASSERTION1213 }1214 fn cast(syntax: SyntaxNode) -> Option<Self> {1215 if Self::can_cast(syntax.kind()) {1216 Some(Self { syntax })1217 } else {1218 None1219 }1220 }1221 fn syntax(&self) -> &SyntaxNode {1222 &self.syntax1223 }1224}1225impl AstNode for ExprBinary {1226 fn can_cast(kind: SyntaxKind) -> bool {1227 kind == EXPR_BINARY1228 }1229 fn cast(syntax: SyntaxNode) -> Option<Self> {1230 if Self::can_cast(syntax.kind()) {1231 Some(Self { syntax })1232 } else {1233 None1234 }1235 }1236 fn syntax(&self) -> &SyntaxNode {1237 &self.syntax1238 }1239}1240impl AstNode for ExprUnary {1241 fn can_cast(kind: SyntaxKind) -> bool {1242 kind == EXPR_UNARY1243 }1244 fn cast(syntax: SyntaxNode) -> Option<Self> {1245 if Self::can_cast(syntax.kind()) {1246 Some(Self { syntax })1247 } else {1248 None1249 }1250 }1251 fn syntax(&self) -> &SyntaxNode {1252 &self.syntax1253 }1254}1255impl AstNode for ExprObjExtend {1256 fn can_cast(kind: SyntaxKind) -> bool {1257 kind == EXPR_OBJ_EXTEND1258 }1259 fn cast(syntax: SyntaxNode) -> Option<Self> {1260 if Self::can_cast(syntax.kind()) {1261 Some(Self { syntax })1262 } else {1263 None1264 }1265 }1266 fn syntax(&self) -> &SyntaxNode {1267 &self.syntax1268 }1269}1270impl AstNode for ExprParened {1271 fn can_cast(kind: SyntaxKind) -> bool {1272 kind == EXPR_PARENED1273 }1274 fn cast(syntax: SyntaxNode) -> Option<Self> {1275 if Self::can_cast(syntax.kind()) {1276 Some(Self { syntax })1277 } else {1278 None1279 }1280 }1281 fn syntax(&self) -> &SyntaxNode {1282 &self.syntax1283 }1284}1285impl AstNode for ExprLiteral {1286 fn can_cast(kind: SyntaxKind) -> bool {1287 kind == EXPR_LITERAL1288 }1289 fn cast(syntax: SyntaxNode) -> Option<Self> {1290 if Self::can_cast(syntax.kind()) {1291 Some(Self { syntax })1292 } else {1293 None1294 }1295 }1296 fn syntax(&self) -> &SyntaxNode {1297 &self.syntax1298 }1299}1300impl AstNode for ExprString {1301 fn can_cast(kind: SyntaxKind) -> bool {1302 kind == EXPR_STRING1303 }1304 fn cast(syntax: SyntaxNode) -> Option<Self> {1305 if Self::can_cast(syntax.kind()) {1306 Some(Self { syntax })1307 } else {1308 None1309 }1310 }1311 fn syntax(&self) -> &SyntaxNode {1312 &self.syntax1313 }1314}1315impl AstNode for ExprNumber {1316 fn can_cast(kind: SyntaxKind) -> bool {1317 kind == EXPR_NUMBER1318 }1319 fn cast(syntax: SyntaxNode) -> Option<Self> {1320 if Self::can_cast(syntax.kind()) {1321 Some(Self { syntax })1322 } else {1323 None1324 }1325 }1326 fn syntax(&self) -> &SyntaxNode {1327 &self.syntax1328 }1329}1330impl AstNode for ExprArray {1331 fn can_cast(kind: SyntaxKind) -> bool {1332 kind == EXPR_ARRAY1333 }1334 fn cast(syntax: SyntaxNode) -> Option<Self> {1335 if Self::can_cast(syntax.kind()) {1336 Some(Self { syntax })1337 } else {1338 None1339 }1340 }1341 fn syntax(&self) -> &SyntaxNode {1342 &self.syntax1343 }1344}1345impl AstNode for ExprObject {1346 fn can_cast(kind: SyntaxKind) -> bool {1347 kind == EXPR_OBJECT1348 }1349 fn cast(syntax: SyntaxNode) -> Option<Self> {1350 if Self::can_cast(syntax.kind()) {1351 Some(Self { syntax })1352 } else {1353 None1354 }1355 }1356 fn syntax(&self) -> &SyntaxNode {1357 &self.syntax1358 }1359}1360impl AstNode for ExprArrayComp {1361 fn can_cast(kind: SyntaxKind) -> bool {1362 kind == EXPR_ARRAY_COMP1363 }1364 fn cast(syntax: SyntaxNode) -> Option<Self> {1365 if Self::can_cast(syntax.kind()) {1366 Some(Self { syntax })1367 } else {1368 None1369 }1370 }1371 fn syntax(&self) -> &SyntaxNode {1372 &self.syntax1373 }1374}1375impl AstNode for ExprImport {1376 fn can_cast(kind: SyntaxKind) -> bool {1377 kind == EXPR_IMPORT1378 }1379 fn cast(syntax: SyntaxNode) -> Option<Self> {1380 if Self::can_cast(syntax.kind()) {1381 Some(Self { syntax })1382 } else {1383 None1384 }1385 }1386 fn syntax(&self) -> &SyntaxNode {1387 &self.syntax1388 }1389}1390impl AstNode for ExprVar {1391 fn can_cast(kind: SyntaxKind) -> bool {1392 kind == EXPR_VAR1393 }1394 fn cast(syntax: SyntaxNode) -> Option<Self> {1395 if Self::can_cast(syntax.kind()) {1396 Some(Self { syntax })1397 } else {1398 None1399 }1400 }1401 fn syntax(&self) -> &SyntaxNode {1402 &self.syntax1403 }1404}1405impl AstNode for ExprIfThenElse {1406 fn can_cast(kind: SyntaxKind) -> bool {1407 kind == EXPR_IF_THEN_ELSE1408 }1409 fn cast(syntax: SyntaxNode) -> Option<Self> {1410 if Self::can_cast(syntax.kind()) {1411 Some(Self { syntax })1412 } else {1413 None1414 }1415 }1416 fn syntax(&self) -> &SyntaxNode {1417 &self.syntax1418 }1419}1420impl AstNode for TrueExpr {1421 fn can_cast(kind: SyntaxKind) -> bool {1422 kind == TRUE_EXPR1423 }1424 fn cast(syntax: SyntaxNode) -> Option<Self> {1425 if Self::can_cast(syntax.kind()) {1426 Some(Self { syntax })1427 } else {1428 None1429 }1430 }1431 fn syntax(&self) -> &SyntaxNode {1432 &self.syntax1433 }1434}1435impl AstNode for FalseExpr {1436 fn can_cast(kind: SyntaxKind) -> bool {1437 kind == FALSE_EXPR1438 }1439 fn cast(syntax: SyntaxNode) -> Option<Self> {1440 if Self::can_cast(syntax.kind()) {1441 Some(Self { syntax })1442 } else {1443 None1444 }1445 }1446 fn syntax(&self) -> &SyntaxNode {1447 &self.syntax1448 }1449}1450impl AstNode for ExprFunction {1451 fn can_cast(kind: SyntaxKind) -> bool {1452 kind == EXPR_FUNCTION1453 }1454 fn cast(syntax: SyntaxNode) -> Option<Self> {1455 if Self::can_cast(syntax.kind()) {1456 Some(Self { syntax })1457 } else {1458 None1459 }1460 }1461 fn syntax(&self) -> &SyntaxNode {1462 &self.syntax1463 }1464}1465impl AstNode for ParamsDesc {1466 fn can_cast(kind: SyntaxKind) -> bool {1467 kind == PARAMS_DESC1468 }1469 fn cast(syntax: SyntaxNode) -> Option<Self> {1470 if Self::can_cast(syntax.kind()) {1471 Some(Self { syntax })1472 } else {1473 None1474 }1475 }1476 fn syntax(&self) -> &SyntaxNode {1477 &self.syntax1478 }1479}1480impl AstNode for ExprError {1481 fn can_cast(kind: SyntaxKind) -> bool {1482 kind == EXPR_ERROR1483 }1484 fn cast(syntax: SyntaxNode) -> Option<Self> {1485 if Self::can_cast(syntax.kind()) {1486 Some(Self { syntax })1487 } else {1488 None1489 }1490 }1491 fn syntax(&self) -> &SyntaxNode {1492 &self.syntax1493 }1494}1495impl AstNode for SliceDescEnd {1496 fn can_cast(kind: SyntaxKind) -> bool {1497 kind == SLICE_DESC_END1498 }1499 fn cast(syntax: SyntaxNode) -> Option<Self> {1500 if Self::can_cast(syntax.kind()) {1501 Some(Self { syntax })1502 } else {1503 None1504 }1505 }1506 fn syntax(&self) -> &SyntaxNode {1507 &self.syntax1508 }1509}1510impl AstNode for SliceDescStep {1511 fn can_cast(kind: SyntaxKind) -> bool {1512 kind == SLICE_DESC_STEP1513 }1514 fn cast(syntax: SyntaxNode) -> Option<Self> {1515 if Self::can_cast(syntax.kind()) {1516 Some(Self { syntax })1517 } else {1518 None1519 }1520 }1521 fn syntax(&self) -> &SyntaxNode {1522 &self.syntax1523 }1524}1525impl AstNode for Arg {1526 fn can_cast(kind: SyntaxKind) -> bool {1527 kind == ARG1528 }1529 fn cast(syntax: SyntaxNode) -> Option<Self> {1530 if Self::can_cast(syntax.kind()) {1531 Some(Self { syntax })1532 } else {1533 None1534 }1535 }1536 fn syntax(&self) -> &SyntaxNode {1537 &self.syntax1538 }1539}1540impl AstNode for ObjBodyComp {1541 fn can_cast(kind: SyntaxKind) -> bool {1542 kind == OBJ_BODY_COMP1543 }1544 fn cast(syntax: SyntaxNode) -> Option<Self> {1545 if Self::can_cast(syntax.kind()) {1546 Some(Self { syntax })1547 } else {1548 None1549 }1550 }1551 fn syntax(&self) -> &SyntaxNode {1552 &self.syntax1553 }1554}1555impl AstNode for ObjBodyMemberList {1556 fn can_cast(kind: SyntaxKind) -> bool {1557 kind == OBJ_BODY_MEMBER_LIST1558 }1559 fn cast(syntax: SyntaxNode) -> Option<Self> {1560 if Self::can_cast(syntax.kind()) {1561 Some(Self { syntax })1562 } else {1563 None1564 }1565 }1566 fn syntax(&self) -> &SyntaxNode {1567 &self.syntax1568 }1569}1570impl AstNode for MemberBindStmt {1571 fn can_cast(kind: SyntaxKind) -> bool {1572 kind == MEMBER_BIND_STMT1573 }1574 fn cast(syntax: SyntaxNode) -> Option<Self> {1575 if Self::can_cast(syntax.kind()) {1576 Some(Self { syntax })1577 } else {1578 None1579 }1580 }1581 fn syntax(&self) -> &SyntaxNode {1582 &self.syntax1583 }1584}1585impl AstNode for ObjLocal {1586 fn can_cast(kind: SyntaxKind) -> bool {1587 kind == OBJ_LOCAL1588 }1589 fn cast(syntax: SyntaxNode) -> Option<Self> {1590 if Self::can_cast(syntax.kind()) {1591 Some(Self { syntax })1592 } else {1593 None1594 }1595 }1596 fn syntax(&self) -> &SyntaxNode {1597 &self.syntax1598 }1599}1600impl AstNode for MemberAssertStmt {1601 fn can_cast(kind: SyntaxKind) -> bool {1602 kind == MEMBER_ASSERT_STMT1603 }1604 fn cast(syntax: SyntaxNode) -> Option<Self> {1605 if Self::can_cast(syntax.kind()) {1606 Some(Self { syntax })1607 } else {1608 None1609 }1610 }1611 fn syntax(&self) -> &SyntaxNode {1612 &self.syntax1613 }1614}1615impl AstNode for MemberFieldNormal {1616 fn can_cast(kind: SyntaxKind) -> bool {1617 kind == MEMBER_FIELD_NORMAL1618 }1619 fn cast(syntax: SyntaxNode) -> Option<Self> {1620 if Self::can_cast(syntax.kind()) {1621 Some(Self { syntax })1622 } else {1623 None1624 }1625 }1626 fn syntax(&self) -> &SyntaxNode {1627 &self.syntax1628 }1629}1630impl AstNode for Visibility {1631 fn can_cast(kind: SyntaxKind) -> bool {1632 kind == VISIBILITY1633 }1634 fn cast(syntax: SyntaxNode) -> Option<Self> {1635 if Self::can_cast(syntax.kind()) {1636 Some(Self { syntax })1637 } else {1638 None1639 }1640 }1641 fn syntax(&self) -> &SyntaxNode {1642 &self.syntax1643 }1644}1645impl AstNode for MemberFieldMethod {1646 fn can_cast(kind: SyntaxKind) -> bool {1647 kind == MEMBER_FIELD_METHOD1648 }1649 fn cast(syntax: SyntaxNode) -> Option<Self> {1650 if Self::can_cast(syntax.kind()) {1651 Some(Self { syntax })1652 } else {1653 None1654 }1655 }1656 fn syntax(&self) -> &SyntaxNode {1657 &self.syntax1658 }1659}1660impl AstNode for FieldNameFixed {1661 fn can_cast(kind: SyntaxKind) -> bool {1662 kind == FIELD_NAME_FIXED1663 }1664 fn cast(syntax: SyntaxNode) -> Option<Self> {1665 if Self::can_cast(syntax.kind()) {1666 Some(Self { syntax })1667 } else {1668 None1669 }1670 }1671 fn syntax(&self) -> &SyntaxNode {1672 &self.syntax1673 }1674}1675impl AstNode for FieldNameDynamic {1676 fn can_cast(kind: SyntaxKind) -> bool {1677 kind == FIELD_NAME_DYNAMIC1678 }1679 fn cast(syntax: SyntaxNode) -> Option<Self> {1680 if Self::can_cast(syntax.kind()) {1681 Some(Self { syntax })1682 } else {1683 None1684 }1685 }1686 fn syntax(&self) -> &SyntaxNode {1687 &self.syntax1688 }1689}1690impl AstNode for ForSpec {1691 fn can_cast(kind: SyntaxKind) -> bool {1692 kind == FOR_SPEC1693 }1694 fn cast(syntax: SyntaxNode) -> Option<Self> {1695 if Self::can_cast(syntax.kind()) {1696 Some(Self { syntax })1697 } else {1698 None1699 }1700 }1701 fn syntax(&self) -> &SyntaxNode {1702 &self.syntax1703 }1704}1705impl AstNode for IfSpec {1706 fn can_cast(kind: SyntaxKind) -> bool {1707 kind == IF_SPEC1708 }1709 fn cast(syntax: SyntaxNode) -> Option<Self> {1710 if Self::can_cast(syntax.kind()) {1711 Some(Self { syntax })1712 } else {1713 None1714 }1715 }1716 fn syntax(&self) -> &SyntaxNode {1717 &self.syntax1718 }1719}1720impl AstNode for BindDestruct {1721 fn can_cast(kind: SyntaxKind) -> bool {1722 kind == BIND_DESTRUCT1723 }1724 fn cast(syntax: SyntaxNode) -> Option<Self> {1725 if Self::can_cast(syntax.kind()) {1726 Some(Self { syntax })1727 } else {1728 None1729 }1730 }1731 fn syntax(&self) -> &SyntaxNode {1732 &self.syntax1733 }1734}1735impl AstNode for BindFunction {1736 fn can_cast(kind: SyntaxKind) -> bool {1737 kind == BIND_FUNCTION1738 }1739 fn cast(syntax: SyntaxNode) -> Option<Self> {1740 if Self::can_cast(syntax.kind()) {1741 Some(Self { syntax })1742 } else {1743 None1744 }1745 }1746 fn syntax(&self) -> &SyntaxNode {1747 &self.syntax1748 }1749}1750impl AstNode for Param {1751 fn can_cast(kind: SyntaxKind) -> bool {1752 kind == PARAM1753 }1754 fn cast(syntax: SyntaxNode) -> Option<Self> {1755 if Self::can_cast(syntax.kind()) {1756 Some(Self { syntax })1757 } else {1758 None1759 }1760 }1761 fn syntax(&self) -> &SyntaxNode {1762 &self.syntax1763 }1764}1765impl AstNode for DestructFull {1766 fn can_cast(kind: SyntaxKind) -> bool {1767 kind == DESTRUCT_FULL1768 }1769 fn cast(syntax: SyntaxNode) -> Option<Self> {1770 if Self::can_cast(syntax.kind()) {1771 Some(Self { syntax })1772 } else {1773 None1774 }1775 }1776 fn syntax(&self) -> &SyntaxNode {1777 &self.syntax1778 }1779}1780impl AstNode for DestructSkip {1781 fn can_cast(kind: SyntaxKind) -> bool {1782 kind == DESTRUCT_SKIP1783 }1784 fn cast(syntax: SyntaxNode) -> Option<Self> {1785 if Self::can_cast(syntax.kind()) {1786 Some(Self { syntax })1787 } else {1788 None1789 }1790 }1791 fn syntax(&self) -> &SyntaxNode {1792 &self.syntax1793 }1794}1795impl AstNode for DestructArray {1796 fn can_cast(kind: SyntaxKind) -> bool {1797 kind == DESTRUCT_ARRAY1798 }1799 fn cast(syntax: SyntaxNode) -> Option<Self> {1800 if Self::can_cast(syntax.kind()) {1801 Some(Self { syntax })1802 } else {1803 None1804 }1805 }1806 fn syntax(&self) -> &SyntaxNode {1807 &self.syntax1808 }1809}1810impl AstNode for DestructObject {1811 fn can_cast(kind: SyntaxKind) -> bool {1812 kind == DESTRUCT_OBJECT1813 }1814 fn cast(syntax: SyntaxNode) -> Option<Self> {1815 if Self::can_cast(syntax.kind()) {1816 Some(Self { syntax })1817 } else {1818 None1819 }1820 }1821 fn syntax(&self) -> &SyntaxNode {1822 &self.syntax1823 }1824}1825impl AstNode for DestructObjectField {1826 fn can_cast(kind: SyntaxKind) -> bool {1827 kind == DESTRUCT_OBJECT_FIELD1828 }1829 fn cast(syntax: SyntaxNode) -> Option<Self> {1830 if Self::can_cast(syntax.kind()) {1831 Some(Self { syntax })1832 } else {1833 None1834 }1835 }1836 fn syntax(&self) -> &SyntaxNode {1837 &self.syntax1838 }1839}1840impl AstNode for DestructRest {1841 fn can_cast(kind: SyntaxKind) -> bool {1842 kind == DESTRUCT_REST1843 }1844 fn cast(syntax: SyntaxNode) -> Option<Self> {1845 if Self::can_cast(syntax.kind()) {1846 Some(Self { syntax })1847 } else {1848 None1849 }1850 }1851 fn syntax(&self) -> &SyntaxNode {1852 &self.syntax1853 }1854}1855impl AstNode for DestructArrayElement {1856 fn can_cast(kind: SyntaxKind) -> bool {1857 kind == DESTRUCT_ARRAY_ELEMENT1858 }1859 fn cast(syntax: SyntaxNode) -> Option<Self> {1860 if Self::can_cast(syntax.kind()) {1861 Some(Self { syntax })1862 } else {1863 None1864 }1865 }1866 fn syntax(&self) -> &SyntaxNode {1867 &self.syntax1868 }1869}1870impl From<SuffixIndex> for Suffix {1871 fn from(node: SuffixIndex) -> Suffix {1872 Suffix::SuffixIndex(node)1873 }1874}1875impl From<SuffixIndexExpr> for Suffix {1876 fn from(node: SuffixIndexExpr) -> Suffix {1877 Suffix::SuffixIndexExpr(node)1878 }1879}1880impl From<SuffixSlice> for Suffix {1881 fn from(node: SuffixSlice) -> Suffix {1882 Suffix::SuffixSlice(node)1883 }1884}1885impl From<SuffixApply> for Suffix {1886 fn from(node: SuffixApply) -> Suffix {1887 Suffix::SuffixApply(node)1888 }1889}1890impl AstNode for Suffix {1891 fn can_cast(kind: SyntaxKind) -> bool {1892 match kind {1893 SUFFIX_INDEX | SUFFIX_INDEX_EXPR | SUFFIX_SLICE | SUFFIX_APPLY => true,1894 _ => false,1895 }1896 }1897 fn cast(syntax: SyntaxNode) -> Option<Self> {1898 let res = match syntax.kind() {1899 SUFFIX_INDEX => Suffix::SuffixIndex(SuffixIndex { syntax }),1900 SUFFIX_INDEX_EXPR => Suffix::SuffixIndexExpr(SuffixIndexExpr { syntax }),1901 SUFFIX_SLICE => Suffix::SuffixSlice(SuffixSlice { syntax }),1902 SUFFIX_APPLY => Suffix::SuffixApply(SuffixApply { syntax }),1903 _ => return None,1904 };1905 Some(res)1906 }1907 fn syntax(&self) -> &SyntaxNode {1908 match self {1909 Suffix::SuffixIndex(it) => &it.syntax,1910 Suffix::SuffixIndexExpr(it) => &it.syntax,1911 Suffix::SuffixSlice(it) => &it.syntax,1912 Suffix::SuffixApply(it) => &it.syntax,1913 }1914 }1915}1916impl From<BindDestruct> for Bind {1917 fn from(node: BindDestruct) -> Bind {1918 Bind::BindDestruct(node)1919 }1920}1921impl From<BindFunction> for Bind {1922 fn from(node: BindFunction) -> Bind {1923 Bind::BindFunction(node)1924 }1925}1926impl AstNode for Bind {1927 fn can_cast(kind: SyntaxKind) -> bool {1928 match kind {1929 BIND_DESTRUCT | BIND_FUNCTION => true,1930 _ => false,1931 }1932 }1933 fn cast(syntax: SyntaxNode) -> Option<Self> {1934 let res = match syntax.kind() {1935 BIND_DESTRUCT => Bind::BindDestruct(BindDestruct { syntax }),1936 BIND_FUNCTION => Bind::BindFunction(BindFunction { syntax }),1937 _ => return None,1938 };1939 Some(res)1940 }1941 fn syntax(&self) -> &SyntaxNode {1942 match self {1943 Bind::BindDestruct(it) => &it.syntax,1944 Bind::BindFunction(it) => &it.syntax,1945 }1946 }1947}1948impl From<StmtLocal> for Stmt {1949 fn from(node: StmtLocal) -> Stmt {1950 Stmt::StmtLocal(node)1951 }1952}1953impl From<StmtAssert> for Stmt {1954 fn from(node: StmtAssert) -> Stmt {1955 Stmt::StmtAssert(node)1956 }1957}1958impl AstNode for Stmt {1959 fn can_cast(kind: SyntaxKind) -> bool {1960 match kind {1961 STMT_LOCAL | STMT_ASSERT => true,1962 _ => false,1963 }1964 }1965 fn cast(syntax: SyntaxNode) -> Option<Self> {1966 let res = match syntax.kind() {1967 STMT_LOCAL => Stmt::StmtLocal(StmtLocal { syntax }),1968 STMT_ASSERT => Stmt::StmtAssert(StmtAssert { syntax }),1969 _ => return None,1970 };1971 Some(res)1972 }1973 fn syntax(&self) -> &SyntaxNode {1974 match self {1975 Stmt::StmtLocal(it) => &it.syntax,1976 Stmt::StmtAssert(it) => &it.syntax,1977 }1978 }1979}1980impl From<ObjBodyComp> for ObjBody {1981 fn from(node: ObjBodyComp) -> ObjBody {1982 ObjBody::ObjBodyComp(node)1983 }1984}1985impl From<ObjBodyMemberList> for ObjBody {1986 fn from(node: ObjBodyMemberList) -> ObjBody {1987 ObjBody::ObjBodyMemberList(node)1988 }1989}1990impl AstNode for ObjBody {1991 fn can_cast(kind: SyntaxKind) -> bool {1992 match kind {1993 OBJ_BODY_COMP | OBJ_BODY_MEMBER_LIST => true,1994 _ => false,1995 }1996 }1997 fn cast(syntax: SyntaxNode) -> Option<Self> {1998 let res = match syntax.kind() {1999 OBJ_BODY_COMP => ObjBody::ObjBodyComp(ObjBodyComp { syntax }),2000 OBJ_BODY_MEMBER_LIST => ObjBody::ObjBodyMemberList(ObjBodyMemberList { syntax }),2001 _ => return None,2002 };2003 Some(res)2004 }2005 fn syntax(&self) -> &SyntaxNode {2006 match self {2007 ObjBody::ObjBodyComp(it) => &it.syntax,2008 ObjBody::ObjBodyMemberList(it) => &it.syntax,2009 }2010 }2011}2012impl From<ForSpec> for CompSpec {2013 fn from(node: ForSpec) -> CompSpec {2014 CompSpec::ForSpec(node)2015 }2016}2017impl From<IfSpec> for CompSpec {2018 fn from(node: IfSpec) -> CompSpec {2019 CompSpec::IfSpec(node)2020 }2021}2022impl AstNode for CompSpec {2023 fn can_cast(kind: SyntaxKind) -> bool {2024 match kind {2025 FOR_SPEC | IF_SPEC => true,2026 _ => false,2027 }2028 }2029 fn cast(syntax: SyntaxNode) -> Option<Self> {2030 let res = match syntax.kind() {2031 FOR_SPEC => CompSpec::ForSpec(ForSpec { syntax }),2032 IF_SPEC => CompSpec::IfSpec(IfSpec { syntax }),2033 _ => return None,2034 };2035 Some(res)2036 }2037 fn syntax(&self) -> &SyntaxNode {2038 match self {2039 CompSpec::ForSpec(it) => &it.syntax,2040 CompSpec::IfSpec(it) => &it.syntax,2041 }2042 }2043}2044impl From<ExprBinary> for ExprBase {2045 fn from(node: ExprBinary) -> ExprBase {2046 ExprBase::ExprBinary(node)2047 }2048}2049impl From<ExprUnary> for ExprBase {2050 fn from(node: ExprUnary) -> ExprBase {2051 ExprBase::ExprUnary(node)2052 }2053}2054impl From<ExprObjExtend> for ExprBase {2055 fn from(node: ExprObjExtend) -> ExprBase {2056 ExprBase::ExprObjExtend(node)2057 }2058}2059impl From<ExprParened> for ExprBase {2060 fn from(node: ExprParened) -> ExprBase {2061 ExprBase::ExprParened(node)2062 }2063}2064impl From<ExprString> for ExprBase {2065 fn from(node: ExprString) -> ExprBase {2066 ExprBase::ExprString(node)2067 }2068}2069impl From<ExprNumber> for ExprBase {2070 fn from(node: ExprNumber) -> ExprBase {2071 ExprBase::ExprNumber(node)2072 }2073}2074impl From<ExprLiteral> for ExprBase {2075 fn from(node: ExprLiteral) -> ExprBase {2076 ExprBase::ExprLiteral(node)2077 }2078}2079impl From<ExprArray> for ExprBase {2080 fn from(node: ExprArray) -> ExprBase {2081 ExprBase::ExprArray(node)2082 }2083}2084impl From<ExprObject> for ExprBase {2085 fn from(node: ExprObject) -> ExprBase {2086 ExprBase::ExprObject(node)2087 }2088}2089impl From<ExprArrayComp> for ExprBase {2090 fn from(node: ExprArrayComp) -> ExprBase {2091 ExprBase::ExprArrayComp(node)2092 }2093}2094impl From<ExprImport> for ExprBase {2095 fn from(node: ExprImport) -> ExprBase {2096 ExprBase::ExprImport(node)2097 }2098}2099impl From<ExprVar> for ExprBase {2100 fn from(node: ExprVar) -> ExprBase {2101 ExprBase::ExprVar(node)2102 }2103}2104impl From<ExprIfThenElse> for ExprBase {2105 fn from(node: ExprIfThenElse) -> ExprBase {2106 ExprBase::ExprIfThenElse(node)2107 }2108}2109impl From<ExprFunction> for ExprBase {2110 fn from(node: ExprFunction) -> ExprBase {2111 ExprBase::ExprFunction(node)2112 }2113}2114impl From<ExprError> for ExprBase {2115 fn from(node: ExprError) -> ExprBase {2116 ExprBase::ExprError(node)2117 }2118}2119impl AstNode for ExprBase {2120 fn can_cast(kind: SyntaxKind) -> bool {2121 match kind {2122 EXPR_BINARY | EXPR_UNARY | EXPR_OBJ_EXTEND | EXPR_PARENED | EXPR_STRING2123 | EXPR_NUMBER | EXPR_LITERAL | EXPR_ARRAY | EXPR_OBJECT | EXPR_ARRAY_COMP2124 | EXPR_IMPORT | EXPR_VAR | EXPR_IF_THEN_ELSE | EXPR_FUNCTION | EXPR_ERROR => true,2125 _ => false,2126 }2127 }2128 fn cast(syntax: SyntaxNode) -> Option<Self> {2129 let res = match syntax.kind() {2130 EXPR_BINARY => ExprBase::ExprBinary(ExprBinary { syntax }),2131 EXPR_UNARY => ExprBase::ExprUnary(ExprUnary { syntax }),2132 EXPR_OBJ_EXTEND => ExprBase::ExprObjExtend(ExprObjExtend { syntax }),2133 EXPR_PARENED => ExprBase::ExprParened(ExprParened { syntax }),2134 EXPR_STRING => ExprBase::ExprString(ExprString { syntax }),2135 EXPR_NUMBER => ExprBase::ExprNumber(ExprNumber { syntax }),2136 EXPR_LITERAL => ExprBase::ExprLiteral(ExprLiteral { syntax }),2137 EXPR_ARRAY => ExprBase::ExprArray(ExprArray { syntax }),2138 EXPR_OBJECT => ExprBase::ExprObject(ExprObject { syntax }),2139 EXPR_ARRAY_COMP => ExprBase::ExprArrayComp(ExprArrayComp { syntax }),2140 EXPR_IMPORT => ExprBase::ExprImport(ExprImport { syntax }),2141 EXPR_VAR => ExprBase::ExprVar(ExprVar { syntax }),2142 EXPR_IF_THEN_ELSE => ExprBase::ExprIfThenElse(ExprIfThenElse { syntax }),2143 EXPR_FUNCTION => ExprBase::ExprFunction(ExprFunction { syntax }),2144 EXPR_ERROR => ExprBase::ExprError(ExprError { syntax }),2145 _ => return None,2146 };2147 Some(res)2148 }2149 fn syntax(&self) -> &SyntaxNode {2150 match self {2151 ExprBase::ExprBinary(it) => &it.syntax,2152 ExprBase::ExprUnary(it) => &it.syntax,2153 ExprBase::ExprObjExtend(it) => &it.syntax,2154 ExprBase::ExprParened(it) => &it.syntax,2155 ExprBase::ExprString(it) => &it.syntax,2156 ExprBase::ExprNumber(it) => &it.syntax,2157 ExprBase::ExprLiteral(it) => &it.syntax,2158 ExprBase::ExprArray(it) => &it.syntax,2159 ExprBase::ExprObject(it) => &it.syntax,2160 ExprBase::ExprArrayComp(it) => &it.syntax,2161 ExprBase::ExprImport(it) => &it.syntax,2162 ExprBase::ExprVar(it) => &it.syntax,2163 ExprBase::ExprIfThenElse(it) => &it.syntax,2164 ExprBase::ExprFunction(it) => &it.syntax,2165 ExprBase::ExprError(it) => &it.syntax,2166 }2167 }2168}2169impl From<MemberBindStmt> for MemberComp {2170 fn from(node: MemberBindStmt) -> MemberComp {2171 MemberComp::MemberBindStmt(node)2172 }2173}2174impl From<MemberFieldNormal> for MemberComp {2175 fn from(node: MemberFieldNormal) -> MemberComp {2176 MemberComp::MemberFieldNormal(node)2177 }2178}2179impl From<MemberFieldMethod> for MemberComp {2180 fn from(node: MemberFieldMethod) -> MemberComp {2181 MemberComp::MemberFieldMethod(node)2182 }2183}2184impl AstNode for MemberComp {2185 fn can_cast(kind: SyntaxKind) -> bool {2186 match kind {2187 MEMBER_BIND_STMT | MEMBER_FIELD_NORMAL | MEMBER_FIELD_METHOD => true,2188 _ => false,2189 }2190 }2191 fn cast(syntax: SyntaxNode) -> Option<Self> {2192 let res = match syntax.kind() {2193 MEMBER_BIND_STMT => MemberComp::MemberBindStmt(MemberBindStmt { syntax }),2194 MEMBER_FIELD_NORMAL => MemberComp::MemberFieldNormal(MemberFieldNormal { syntax }),2195 MEMBER_FIELD_METHOD => MemberComp::MemberFieldMethod(MemberFieldMethod { syntax }),2196 _ => return None,2197 };2198 Some(res)2199 }2200 fn syntax(&self) -> &SyntaxNode {2201 match self {2202 MemberComp::MemberBindStmt(it) => &it.syntax,2203 MemberComp::MemberFieldNormal(it) => &it.syntax,2204 MemberComp::MemberFieldMethod(it) => &it.syntax,2205 }2206 }2207}2208impl From<MemberBindStmt> for Member {2209 fn from(node: MemberBindStmt) -> Member {2210 Member::MemberBindStmt(node)2211 }2212}2213impl From<MemberAssertStmt> for Member {2214 fn from(node: MemberAssertStmt) -> Member {2215 Member::MemberAssertStmt(node)2216 }2217}2218impl From<MemberFieldNormal> for Member {2219 fn from(node: MemberFieldNormal) -> Member {2220 Member::MemberFieldNormal(node)2221 }2222}2223impl From<MemberFieldMethod> for Member {2224 fn from(node: MemberFieldMethod) -> Member {2225 Member::MemberFieldMethod(node)2226 }2227}2228impl AstNode for Member {2229 fn can_cast(kind: SyntaxKind) -> bool {2230 match kind {2231 MEMBER_BIND_STMT | MEMBER_ASSERT_STMT | MEMBER_FIELD_NORMAL | MEMBER_FIELD_METHOD => {2232 true2233 }2234 _ => false,2235 }2236 }2237 fn cast(syntax: SyntaxNode) -> Option<Self> {2238 let res = match syntax.kind() {2239 MEMBER_BIND_STMT => Member::MemberBindStmt(MemberBindStmt { syntax }),2240 MEMBER_ASSERT_STMT => Member::MemberAssertStmt(MemberAssertStmt { syntax }),2241 MEMBER_FIELD_NORMAL => Member::MemberFieldNormal(MemberFieldNormal { syntax }),2242 MEMBER_FIELD_METHOD => Member::MemberFieldMethod(MemberFieldMethod { syntax }),2243 _ => return None,2244 };2245 Some(res)2246 }2247 fn syntax(&self) -> &SyntaxNode {2248 match self {2249 Member::MemberBindStmt(it) => &it.syntax,2250 Member::MemberAssertStmt(it) => &it.syntax,2251 Member::MemberFieldNormal(it) => &it.syntax,2252 Member::MemberFieldMethod(it) => &it.syntax,2253 }2254 }2255}2256impl From<FieldNameFixed> for FieldName {2257 fn from(node: FieldNameFixed) -> FieldName {2258 FieldName::FieldNameFixed(node)2259 }2260}2261impl From<FieldNameDynamic> for FieldName {2262 fn from(node: FieldNameDynamic) -> FieldName {2263 FieldName::FieldNameDynamic(node)2264 }2265}2266impl AstNode for FieldName {2267 fn can_cast(kind: SyntaxKind) -> bool {2268 match kind {2269 FIELD_NAME_FIXED | FIELD_NAME_DYNAMIC => true,2270 _ => false,2271 }2272 }2273 fn cast(syntax: SyntaxNode) -> Option<Self> {2274 let res = match syntax.kind() {2275 FIELD_NAME_FIXED => FieldName::FieldNameFixed(FieldNameFixed { syntax }),2276 FIELD_NAME_DYNAMIC => FieldName::FieldNameDynamic(FieldNameDynamic { syntax }),2277 _ => return None,2278 };2279 Some(res)2280 }2281 fn syntax(&self) -> &SyntaxNode {2282 match self {2283 FieldName::FieldNameFixed(it) => &it.syntax,2284 FieldName::FieldNameDynamic(it) => &it.syntax,2285 }2286 }2287}2288impl From<DestructFull> for Destruct {2289 fn from(node: DestructFull) -> Destruct {2290 Destruct::DestructFull(node)2291 }2292}2293impl From<DestructSkip> for Destruct {2294 fn from(node: DestructSkip) -> Destruct {2295 Destruct::DestructSkip(node)2296 }2297}2298impl From<DestructArray> for Destruct {2299 fn from(node: DestructArray) -> Destruct {2300 Destruct::DestructArray(node)2301 }2302}2303impl From<DestructObject> for Destruct {2304 fn from(node: DestructObject) -> Destruct {2305 Destruct::DestructObject(node)2306 }2307}2308impl AstNode for Destruct {2309 fn can_cast(kind: SyntaxKind) -> bool {2310 match kind {2311 DESTRUCT_FULL | DESTRUCT_SKIP | DESTRUCT_ARRAY | DESTRUCT_OBJECT => true,2312 _ => false,2313 }2314 }2315 fn cast(syntax: SyntaxNode) -> Option<Self> {2316 let res = match syntax.kind() {2317 DESTRUCT_FULL => Destruct::DestructFull(DestructFull { syntax }),2318 DESTRUCT_SKIP => Destruct::DestructSkip(DestructSkip { syntax }),2319 DESTRUCT_ARRAY => Destruct::DestructArray(DestructArray { syntax }),2320 DESTRUCT_OBJECT => Destruct::DestructObject(DestructObject { syntax }),2321 _ => return None,2322 };2323 Some(res)2324 }2325 fn syntax(&self) -> &SyntaxNode {2326 match self {2327 Destruct::DestructFull(it) => &it.syntax,2328 Destruct::DestructSkip(it) => &it.syntax,2329 Destruct::DestructArray(it) => &it.syntax,2330 Destruct::DestructObject(it) => &it.syntax,2331 }2332 }2333}2334impl From<DestructArrayElement> for DestructArrayPart {2335 fn from(node: DestructArrayElement) -> DestructArrayPart {2336 DestructArrayPart::DestructArrayElement(node)2337 }2338}2339impl From<DestructRest> for DestructArrayPart {2340 fn from(node: DestructRest) -> DestructArrayPart {2341 DestructArrayPart::DestructRest(node)2342 }2343}2344impl AstNode for DestructArrayPart {2345 fn can_cast(kind: SyntaxKind) -> bool {2346 match kind {2347 DESTRUCT_ARRAY_ELEMENT | DESTRUCT_REST => true,2348 _ => false,2349 }2350 }2351 fn cast(syntax: SyntaxNode) -> Option<Self> {2352 let res = match syntax.kind() {2353 DESTRUCT_ARRAY_ELEMENT => {2354 DestructArrayPart::DestructArrayElement(DestructArrayElement { syntax })2355 }2356 DESTRUCT_REST => DestructArrayPart::DestructRest(DestructRest { syntax }),2357 _ => return None,2358 };2359 Some(res)2360 }2361 fn syntax(&self) -> &SyntaxNode {2362 match self {2363 DestructArrayPart::DestructArrayElement(it) => &it.syntax,2364 DestructArrayPart::DestructRest(it) => &it.syntax,2365 }2366 }2367}2368impl AstToken for BinaryOperator {2369 fn can_cast(kind: SyntaxKind) -> bool {2370 BinaryOperatorKind::can_cast(kind)2371 }2372 fn cast(syntax: SyntaxToken) -> Option<Self> {2373 let kind = BinaryOperatorKind::cast(syntax.kind())?;2374 Some(BinaryOperator { syntax, kind })2375 }2376 fn syntax(&self) -> &SyntaxToken {2377 &self.syntax2378 }2379}2380impl BinaryOperatorKind {2381 fn can_cast(kind: SyntaxKind) -> bool {2382 match kind {2383 OR | NULL_COAELSE | AND | BIT_OR | BIT_XOR | BIT_AND | EQ | NE | LT | GT | LE | GE2384 | IN_KW | LHS | RHS | PLUS | MINUS | MUL | DIV | MODULO | META_OBJECT_APPLY2385 | ERROR_NO_OPERATOR => true,2386 _ => false,2387 }2388 }2389 pub fn cast(kind: SyntaxKind) -> Option<Self> {2390 let res = match kind {2391 OR => Self::Or,2392 NULL_COAELSE => Self::NullCoaelse,2393 AND => Self::And,2394 BIT_OR => Self::BitOr,2395 BIT_XOR => Self::BitXor,2396 BIT_AND => Self::BitAnd,2397 EQ => Self::Eq,2398 NE => Self::Ne,2399 LT => Self::Lt,2400 GT => Self::Gt,2401 LE => Self::Le,2402 GE => Self::Ge,2403 IN_KW => Self::InKw,2404 LHS => Self::Lhs,2405 RHS => Self::Rhs,2406 PLUS => Self::Plus,2407 MINUS => Self::Minus,2408 MUL => Self::Mul,2409 DIV => Self::Div,2410 MODULO => Self::Modulo,2411 META_OBJECT_APPLY => Self::MetaObjectApply,2412 ERROR_NO_OPERATOR => Self::ErrorNoOperator,2413 _ => return None,2414 };2415 Some(res)2416 }2417}2418impl BinaryOperator {2419 pub fn kind(&self) -> BinaryOperatorKind {2420 self.kind2421 }2422}2423impl std::fmt::Display for BinaryOperator {2424 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2425 std::fmt::Display::fmt(self.syntax(), f)2426 }2427}2428impl AstToken for UnaryOperator {2429 fn can_cast(kind: SyntaxKind) -> bool {2430 UnaryOperatorKind::can_cast(kind)2431 }2432 fn cast(syntax: SyntaxToken) -> Option<Self> {2433 let kind = UnaryOperatorKind::cast(syntax.kind())?;2434 Some(UnaryOperator { syntax, kind })2435 }2436 fn syntax(&self) -> &SyntaxToken {2437 &self.syntax2438 }2439}2440impl UnaryOperatorKind {2441 fn can_cast(kind: SyntaxKind) -> bool {2442 match kind {2443 MINUS | NOT | BIT_NOT => true,2444 _ => false,2445 }2446 }2447 pub fn cast(kind: SyntaxKind) -> Option<Self> {2448 let res = match kind {2449 MINUS => Self::Minus,2450 NOT => Self::Not,2451 BIT_NOT => Self::BitNot,2452 _ => return None,2453 };2454 Some(res)2455 }2456}2457impl UnaryOperator {2458 pub fn kind(&self) -> UnaryOperatorKind {2459 self.kind2460 }2461}2462impl std::fmt::Display for UnaryOperator {2463 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2464 std::fmt::Display::fmt(self.syntax(), f)2465 }2466}2467impl AstToken for Literal {2468 fn can_cast(kind: SyntaxKind) -> bool {2469 LiteralKind::can_cast(kind)2470 }2471 fn cast(syntax: SyntaxToken) -> Option<Self> {2472 let kind = LiteralKind::cast(syntax.kind())?;2473 Some(Literal { syntax, kind })2474 }2475 fn syntax(&self) -> &SyntaxToken {2476 &self.syntax2477 }2478}2479impl LiteralKind {2480 fn can_cast(kind: SyntaxKind) -> bool {2481 match kind {2482 NULL_KW | TRUE_KW | FALSE_KW | SELF_KW | DOLLAR | SUPER_KW => true,2483 _ => false,2484 }2485 }2486 pub fn cast(kind: SyntaxKind) -> Option<Self> {2487 let res = match kind {2488 NULL_KW => Self::NullKw,2489 TRUE_KW => Self::TrueKw,2490 FALSE_KW => Self::FalseKw,2491 SELF_KW => Self::SelfKw,2492 DOLLAR => Self::Dollar,2493 SUPER_KW => Self::SuperKw,2494 _ => return None,2495 };2496 Some(res)2497 }2498}2499impl Literal {2500 pub fn kind(&self) -> LiteralKind {2501 self.kind2502 }2503}2504impl std::fmt::Display for Literal {2505 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2506 std::fmt::Display::fmt(self.syntax(), f)2507 }2508}2509impl AstToken for Text {2510 fn can_cast(kind: SyntaxKind) -> bool {2511 TextKind::can_cast(kind)2512 }2513 fn cast(syntax: SyntaxToken) -> Option<Self> {2514 let kind = TextKind::cast(syntax.kind())?;2515 Some(Text { syntax, kind })2516 }2517 fn syntax(&self) -> &SyntaxToken {2518 &self.syntax2519 }2520}2521impl TextKind {2522 fn can_cast(kind: SyntaxKind) -> bool {2523 match kind {2524 STRING_DOUBLE2525 | ERROR_STRING_DOUBLE_UNTERMINATED2526 | STRING_SINGLE2527 | ERROR_STRING_SINGLE_UNTERMINATED2528 | STRING_DOUBLE_VERBATIM2529 | ERROR_STRING_DOUBLE_VERBATIM_UNTERMINATED2530 | STRING_SINGLE_VERBATIM2531 | ERROR_STRING_SINGLE_VERBATIM_UNTERMINATED2532 | ERROR_STRING_VERBATIM_MISSING_QUOTES2533 | STRING_BLOCK2534 | ERROR_STRING_BLOCK_UNEXPECTED_END2535 | ERROR_STRING_BLOCK_MISSING_NEW_LINE2536 | ERROR_STRING_BLOCK_MISSING_TERMINATION2537 | ERROR_STRING_BLOCK_MISSING_INDENT => true,2538 _ => false,2539 }2540 }2541 pub fn cast(kind: SyntaxKind) -> Option<Self> {2542 let res = match kind {2543 STRING_DOUBLE => Self::StringDouble,2544 ERROR_STRING_DOUBLE_UNTERMINATED => Self::ErrorStringDoubleUnterminated,2545 STRING_SINGLE => Self::StringSingle,2546 ERROR_STRING_SINGLE_UNTERMINATED => Self::ErrorStringSingleUnterminated,2547 STRING_DOUBLE_VERBATIM => Self::StringDoubleVerbatim,2548 ERROR_STRING_DOUBLE_VERBATIM_UNTERMINATED => {2549 Self::ErrorStringDoubleVerbatimUnterminated2550 }2551 STRING_SINGLE_VERBATIM => Self::StringSingleVerbatim,2552 ERROR_STRING_SINGLE_VERBATIM_UNTERMINATED => {2553 Self::ErrorStringSingleVerbatimUnterminated2554 }2555 ERROR_STRING_VERBATIM_MISSING_QUOTES => Self::ErrorStringVerbatimMissingQuotes,2556 STRING_BLOCK => Self::StringBlock,2557 ERROR_STRING_BLOCK_UNEXPECTED_END => Self::ErrorStringBlockUnexpectedEnd,2558 ERROR_STRING_BLOCK_MISSING_NEW_LINE => Self::ErrorStringBlockMissingNewLine,2559 ERROR_STRING_BLOCK_MISSING_TERMINATION => Self::ErrorStringBlockMissingTermination,2560 ERROR_STRING_BLOCK_MISSING_INDENT => Self::ErrorStringBlockMissingIndent,2561 _ => return None,2562 };2563 Some(res)2564 }2565}2566impl Text {2567 pub fn kind(&self) -> TextKind {2568 self.kind2569 }2570}2571impl std::fmt::Display for Text {2572 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2573 std::fmt::Display::fmt(self.syntax(), f)2574 }2575}2576impl AstToken for Number {2577 fn can_cast(kind: SyntaxKind) -> bool {2578 NumberKind::can_cast(kind)2579 }2580 fn cast(syntax: SyntaxToken) -> Option<Self> {2581 let kind = NumberKind::cast(syntax.kind())?;2582 Some(Number { syntax, kind })2583 }2584 fn syntax(&self) -> &SyntaxToken {2585 &self.syntax2586 }2587}2588impl NumberKind {2589 fn can_cast(kind: SyntaxKind) -> bool {2590 match kind {2591 FLOAT2592 | ERROR_FLOAT_JUNK_AFTER_POINT2593 | ERROR_FLOAT_JUNK_AFTER_EXPONENT2594 | ERROR_FLOAT_JUNK_AFTER_EXPONENT_SIGN => true,2595 _ => false,2596 }2597 }2598 pub fn cast(kind: SyntaxKind) -> Option<Self> {2599 let res = match kind {2600 FLOAT => Self::Float,2601 ERROR_FLOAT_JUNK_AFTER_POINT => Self::ErrorFloatJunkAfterPoint,2602 ERROR_FLOAT_JUNK_AFTER_EXPONENT => Self::ErrorFloatJunkAfterExponent,2603 ERROR_FLOAT_JUNK_AFTER_EXPONENT_SIGN => Self::ErrorFloatJunkAfterExponentSign,2604 _ => return None,2605 };2606 Some(res)2607 }2608}2609impl Number {2610 pub fn kind(&self) -> NumberKind {2611 self.kind2612 }2613}2614impl std::fmt::Display for Number {2615 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2616 std::fmt::Display::fmt(self.syntax(), f)2617 }2618}2619impl AstToken for ImportKind {2620 fn can_cast(kind: SyntaxKind) -> bool {2621 ImportKindKind::can_cast(kind)2622 }2623 fn cast(syntax: SyntaxToken) -> Option<Self> {2624 let kind = ImportKindKind::cast(syntax.kind())?;2625 Some(ImportKind { syntax, kind })2626 }2627 fn syntax(&self) -> &SyntaxToken {2628 &self.syntax2629 }2630}2631impl ImportKindKind {2632 fn can_cast(kind: SyntaxKind) -> bool {2633 match kind {2634 IMPORTSTR_KW | IMPORTBIN_KW | IMPORT_KW => true,2635 _ => false,2636 }2637 }2638 pub fn cast(kind: SyntaxKind) -> Option<Self> {2639 let res = match kind {2640 IMPORTSTR_KW => Self::ImportstrKw,2641 IMPORTBIN_KW => Self::ImportbinKw,2642 IMPORT_KW => Self::ImportKw,2643 _ => return None,2644 };2645 Some(res)2646 }2647}2648impl ImportKind {2649 pub fn kind(&self) -> ImportKindKind {2650 self.kind2651 }2652}2653impl std::fmt::Display for ImportKind {2654 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2655 std::fmt::Display::fmt(self.syntax(), f)2656 }2657}2658impl AstToken for Trivia {2659 fn can_cast(kind: SyntaxKind) -> bool {2660 TriviaKind::can_cast(kind)2661 }2662 fn cast(syntax: SyntaxToken) -> Option<Self> {2663 let kind = TriviaKind::cast(syntax.kind())?;2664 Some(Trivia { syntax, kind })2665 }2666 fn syntax(&self) -> &SyntaxToken {2667 &self.syntax2668 }2669}2670impl TriviaKind {2671 fn can_cast(kind: SyntaxKind) -> bool {2672 match kind {2673 WHITESPACE2674 | MULTI_LINE_COMMENT2675 | ERROR_COMMENT_TOO_SHORT2676 | ERROR_COMMENT_UNTERMINATED2677 | SINGLE_LINE_HASH_COMMENT2678 | SINGLE_LINE_SLASH_COMMENT => true,2679 _ => false,2680 }2681 }2682 pub fn cast(kind: SyntaxKind) -> Option<Self> {2683 let res = match kind {2684 WHITESPACE => Self::Whitespace,2685 MULTI_LINE_COMMENT => Self::MultiLineComment,2686 ERROR_COMMENT_TOO_SHORT => Self::ErrorCommentTooShort,2687 ERROR_COMMENT_UNTERMINATED => Self::ErrorCommentUnterminated,2688 SINGLE_LINE_HASH_COMMENT => Self::SingleLineHashComment,2689 SINGLE_LINE_SLASH_COMMENT => Self::SingleLineSlashComment,2690 _ => return None,2691 };2692 Some(res)2693 }2694}2695impl Trivia {2696 pub fn kind(&self) -> TriviaKind {2697 self.kind2698 }2699}2700impl std::fmt::Display for Trivia {2701 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2702 std::fmt::Display::fmt(self.syntax(), f)2703 }2704}2705impl AstToken for CustomError {2706 fn can_cast(kind: SyntaxKind) -> bool {2707 CustomErrorKind::can_cast(kind)2708 }2709 fn cast(syntax: SyntaxToken) -> Option<Self> {2710 let kind = CustomErrorKind::cast(syntax.kind())?;2711 Some(CustomError { syntax, kind })2712 }2713 fn syntax(&self) -> &SyntaxToken {2714 &self.syntax2715 }2716}2717impl CustomErrorKind {2718 fn can_cast(kind: SyntaxKind) -> bool {2719 match kind {2720 ERROR_MISSING_TOKEN | ERROR_UNEXPECTED_TOKEN | ERROR_CUSTOM => true,2721 _ => false,2722 }2723 }2724 pub fn cast(kind: SyntaxKind) -> Option<Self> {2725 let res = match kind {2726 ERROR_MISSING_TOKEN => Self::ErrorMissingToken,2727 ERROR_UNEXPECTED_TOKEN => Self::ErrorUnexpectedToken,2728 ERROR_CUSTOM => Self::ErrorCustom,2729 _ => return None,2730 };2731 Some(res)2732 }2733}2734impl CustomError {2735 pub fn kind(&self) -> CustomErrorKind {2736 self.kind2737 }2738}2739impl std::fmt::Display for CustomError {2740 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2741 std::fmt::Display::fmt(self.syntax(), f)2742 }2743}2744impl std::fmt::Display for Suffix {2745 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2746 std::fmt::Display::fmt(self.syntax(), f)2747 }2748}2749impl std::fmt::Display for Bind {2750 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2751 std::fmt::Display::fmt(self.syntax(), f)2752 }2753}2754impl std::fmt::Display for Stmt {2755 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2756 std::fmt::Display::fmt(self.syntax(), f)2757 }2758}2759impl std::fmt::Display for ObjBody {2760 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2761 std::fmt::Display::fmt(self.syntax(), f)2762 }2763}2764impl std::fmt::Display for CompSpec {2765 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2766 std::fmt::Display::fmt(self.syntax(), f)2767 }2768}2769impl std::fmt::Display for ExprBase {2770 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2771 std::fmt::Display::fmt(self.syntax(), f)2772 }2773}2774impl std::fmt::Display for MemberComp {2775 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2776 std::fmt::Display::fmt(self.syntax(), f)2777 }2778}2779impl std::fmt::Display for Member {2780 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2781 std::fmt::Display::fmt(self.syntax(), f)2782 }2783}2784impl std::fmt::Display for FieldName {2785 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2786 std::fmt::Display::fmt(self.syntax(), f)2787 }2788}2789impl std::fmt::Display for Destruct {2790 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2791 std::fmt::Display::fmt(self.syntax(), f)2792 }2793}2794impl std::fmt::Display for DestructArrayPart {2795 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2796 std::fmt::Display::fmt(self.syntax(), f)2797 }2798}2799impl std::fmt::Display for SourceFile {2800 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2801 std::fmt::Display::fmt(self.syntax(), f)2802 }2803}2804impl std::fmt::Display for Expr {2805 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2806 std::fmt::Display::fmt(self.syntax(), f)2807 }2808}2809impl std::fmt::Display for SuffixIndex {2810 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2811 std::fmt::Display::fmt(self.syntax(), f)2812 }2813}2814impl std::fmt::Display for Name {2815 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2816 std::fmt::Display::fmt(self.syntax(), f)2817 }2818}2819impl std::fmt::Display for SuffixIndexExpr {2820 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2821 std::fmt::Display::fmt(self.syntax(), f)2822 }2823}2824impl std::fmt::Display for SuffixSlice {2825 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2826 std::fmt::Display::fmt(self.syntax(), f)2827 }2828}2829impl std::fmt::Display for SliceDesc {2830 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2831 std::fmt::Display::fmt(self.syntax(), f)2832 }2833}2834impl std::fmt::Display for SuffixApply {2835 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2836 std::fmt::Display::fmt(self.syntax(), f)2837 }2838}2839impl std::fmt::Display for ArgsDesc {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 StmtLocal {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 StmtAssert {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 Assertion {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 ExprBinary {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 ExprUnary {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 ExprObjExtend {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 ExprParened {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 ExprLiteral {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 ExprString {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 ExprNumber {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 ExprArray {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 ExprObject {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 ExprArrayComp {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 ExprImport {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 ExprVar {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 ExprIfThenElse {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 TrueExpr {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 FalseExpr {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 ExprFunction {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 ParamsDesc {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 ExprError {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 SliceDescEnd {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 SliceDescStep {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 Arg {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 ObjBodyComp {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 ObjBodyMemberList {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 MemberBindStmt {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 ObjLocal {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 MemberAssertStmt {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 MemberFieldNormal {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 Visibility {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 MemberFieldMethod {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 FieldNameFixed {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 FieldNameDynamic {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 ForSpec {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 IfSpec {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 BindDestruct {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 BindFunction {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 Param {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 DestructFull {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 DestructSkip {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 DestructArray {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 DestructObject {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 DestructObjectField {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 DestructRest {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 DestructArrayElement {3070 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3071 std::fmt::Display::fmt(self.syntax(), f)3072 }3073}1//! This is a generated file, please do not edit manually. Changes can be2//! made in codegeneration that lives in `xtask` top-level dir.34#![allow(non_snake_case, clippy::match_like_matches_macro)]5use crate::{6 SyntaxKind::{self, *},7 SyntaxNode, SyntaxToken, T,8 ast::{AstChildren, AstNode, AstToken, support},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::children(&self.syntax).next()18 }19}2021#[derive(Debug, Clone, PartialEq, Eq, Hash)]22pub struct Expr {23 pub(crate) syntax: SyntaxNode,24}25impl Expr {26 pub fn stmts(&self) -> AstChildren<Stmt> {27 support::children(&self.syntax)28 }29 pub fn expr_base(&self) -> Option<ExprBase> {30 support::children(&self.syntax).next()31 }32 pub fn suffixs(&self) -> AstChildren<Suffix> {33 support::children(&self.syntax)34 }35}3637#[derive(Debug, Clone, PartialEq, Eq, Hash)]38pub struct SuffixIndex {39 pub(crate) syntax: SyntaxNode,40}41impl SuffixIndex {42 pub fn question_mark_token(&self) -> Option<SyntaxToken> {43 support::token(&self.syntax, T![?])44 }45 pub fn dot_token(&self) -> Option<SyntaxToken> {46 support::token(&self.syntax, T![.])47 }48 pub fn index(&self) -> Option<Name> {49 support::children(&self.syntax).next()50 }51}5253#[derive(Debug, Clone, PartialEq, Eq, Hash)]54pub struct Name {55 pub(crate) syntax: SyntaxNode,56}57impl Name {58 pub fn ident_lit(&self) -> Option<SyntaxToken> {59 support::token(&self.syntax, IDENT)60 }61}6263#[derive(Debug, Clone, PartialEq, Eq, Hash)]64pub struct SuffixIndexExpr {65 pub(crate) syntax: SyntaxNode,66}67impl SuffixIndexExpr {68 pub fn question_mark_token(&self) -> Option<SyntaxToken> {69 support::token(&self.syntax, T![?])70 }71 pub fn dot_token(&self) -> Option<SyntaxToken> {72 support::token(&self.syntax, T![.])73 }74 pub fn l_brack_token(&self) -> Option<SyntaxToken> {75 support::token(&self.syntax, T!['['])76 }77 pub fn index(&self) -> Option<Expr> {78 support::children(&self.syntax).next()79 }80 pub fn r_brack_token(&self) -> Option<SyntaxToken> {81 support::token(&self.syntax, T![']'])82 }83}8485#[derive(Debug, Clone, PartialEq, Eq, Hash)]86pub struct SuffixSlice {87 pub(crate) syntax: SyntaxNode,88}89impl SuffixSlice {90 pub fn slice_desc(&self) -> Option<SliceDesc> {91 support::children(&self.syntax).next()92 }93}9495#[derive(Debug, Clone, PartialEq, Eq, Hash)]96pub struct SliceDesc {97 pub(crate) syntax: SyntaxNode,98}99impl SliceDesc {100 pub fn l_brack_token(&self) -> Option<SyntaxToken> {101 support::token(&self.syntax, T!['['])102 }103 pub fn from(&self) -> Option<Expr> {104 support::children(&self.syntax).next()105 }106 pub fn colon_token(&self) -> Option<SyntaxToken> {107 support::token(&self.syntax, T![:])108 }109 pub fn end(&self) -> Option<SliceDescEnd> {110 support::children(&self.syntax).next()111 }112 pub fn step(&self) -> Option<SliceDescStep> {113 support::children(&self.syntax).next()114 }115 pub fn r_brack_token(&self) -> Option<SyntaxToken> {116 support::token(&self.syntax, T![']'])117 }118}119120#[derive(Debug, Clone, PartialEq, Eq, Hash)]121pub struct SuffixApply {122 pub(crate) syntax: SyntaxNode,123}124impl SuffixApply {125 pub fn args_desc(&self) -> Option<ArgsDesc> {126 support::children(&self.syntax).next()127 }128 pub fn tailstrict_kw_token(&self) -> Option<SyntaxToken> {129 support::token(&self.syntax, T![tailstrict])130 }131}132133#[derive(Debug, Clone, PartialEq, Eq, Hash)]134pub struct ArgsDesc {135 pub(crate) syntax: SyntaxNode,136}137impl ArgsDesc {138 pub fn l_paren_token(&self) -> Option<SyntaxToken> {139 support::token(&self.syntax, T!['('])140 }141 pub fn args(&self) -> AstChildren<Arg> {142 support::children(&self.syntax)143 }144 pub fn r_paren_token(&self) -> Option<SyntaxToken> {145 support::token(&self.syntax, T![')'])146 }147}148149#[derive(Debug, Clone, PartialEq, Eq, Hash)]150pub struct StmtLocal {151 pub(crate) syntax: SyntaxNode,152}153impl StmtLocal {154 pub fn local_kw_token(&self) -> Option<SyntaxToken> {155 support::token(&self.syntax, T![local])156 }157 pub fn binds(&self) -> AstChildren<Bind> {158 support::children(&self.syntax)159 }160 pub fn semi_token(&self) -> Option<SyntaxToken> {161 support::token(&self.syntax, T![;])162 }163}164165#[derive(Debug, Clone, PartialEq, Eq, Hash)]166pub struct StmtAssert {167 pub(crate) syntax: SyntaxNode,168}169impl StmtAssert {170 pub fn assertion(&self) -> Option<Assertion> {171 support::children(&self.syntax).next()172 }173 pub fn semi_token(&self) -> Option<SyntaxToken> {174 support::token(&self.syntax, T![;])175 }176}177178#[derive(Debug, Clone, PartialEq, Eq, Hash)]179pub struct Assertion {180 pub(crate) syntax: SyntaxNode,181}182impl Assertion {183 pub fn assert_kw_token(&self) -> Option<SyntaxToken> {184 support::token(&self.syntax, T![assert])185 }186 pub fn condition(&self) -> Option<Expr> {187 support::children(&self.syntax).next()188 }189 pub fn colon_token(&self) -> Option<SyntaxToken> {190 support::token(&self.syntax, T![:])191 }192 pub fn message(&self) -> Option<Expr> {193 support::children(&self.syntax).nth(1usize)194 }195}196197#[derive(Debug, Clone, PartialEq, Eq, Hash)]198pub struct ExprBinary {199 pub(crate) syntax: SyntaxNode,200}201impl ExprBinary {202 pub fn lhs(&self) -> Option<Expr> {203 support::children(&self.syntax).next()204 }205 pub fn binary_operator(&self) -> Option<BinaryOperator> {206 support::token_child(&self.syntax)207 }208 pub fn rhs(&self) -> Option<Expr> {209 support::children(&self.syntax).nth(1usize)210 }211}212213#[derive(Debug, Clone, PartialEq, Eq, Hash)]214pub struct ExprUnary {215 pub(crate) syntax: SyntaxNode,216}217impl ExprUnary {218 pub fn unary_operator(&self) -> Option<UnaryOperator> {219 support::token_child(&self.syntax)220 }221 pub fn rhs(&self) -> Option<Expr> {222 support::children(&self.syntax).next()223 }224}225226#[derive(Debug, Clone, PartialEq, Eq, Hash)]227pub struct ExprObjExtend {228 pub(crate) syntax: SyntaxNode,229}230impl ExprObjExtend {231 pub fn lhs(&self) -> Option<Expr> {232 support::children(&self.syntax).next()233 }234 pub fn rhs(&self) -> Option<Expr> {235 support::children(&self.syntax).nth(1usize)236 }237}238239#[derive(Debug, Clone, PartialEq, Eq, Hash)]240pub struct ExprParened {241 pub(crate) syntax: SyntaxNode,242}243impl ExprParened {244 pub fn l_paren_token(&self) -> Option<SyntaxToken> {245 support::token(&self.syntax, T!['('])246 }247 pub fn expr(&self) -> Option<Expr> {248 support::children(&self.syntax).next()249 }250 pub fn r_paren_token(&self) -> Option<SyntaxToken> {251 support::token(&self.syntax, T![')'])252 }253}254255#[derive(Debug, Clone, PartialEq, Eq, Hash)]256pub struct ExprLiteral {257 pub(crate) syntax: SyntaxNode,258}259impl ExprLiteral {260 pub fn literal(&self) -> Option<Literal> {261 support::token_child(&self.syntax)262 }263}264265#[derive(Debug, Clone, PartialEq, Eq, Hash)]266pub struct ExprString {267 pub(crate) syntax: SyntaxNode,268}269impl ExprString {270 pub fn text(&self) -> Option<Text> {271 support::token_child(&self.syntax)272 }273}274275#[derive(Debug, Clone, PartialEq, Eq, Hash)]276pub struct ExprNumber {277 pub(crate) syntax: SyntaxNode,278}279impl ExprNumber {280 pub fn number(&self) -> Option<Number> {281 support::token_child(&self.syntax)282 }283}284285#[derive(Debug, Clone, PartialEq, Eq, Hash)]286pub struct ExprArray {287 pub(crate) syntax: SyntaxNode,288}289impl ExprArray {290 pub fn l_brack_token(&self) -> Option<SyntaxToken> {291 support::token(&self.syntax, T!['['])292 }293 pub fn exprs(&self) -> AstChildren<Expr> {294 support::children(&self.syntax)295 }296 pub fn r_brack_token(&self) -> Option<SyntaxToken> {297 support::token(&self.syntax, T![']'])298 }299}300301#[derive(Debug, Clone, PartialEq, Eq, Hash)]302pub struct ExprObject {303 pub(crate) syntax: SyntaxNode,304}305impl ExprObject {306 pub fn obj_body(&self) -> Option<ObjBody> {307 support::children(&self.syntax).next()308 }309}310311#[derive(Debug, Clone, PartialEq, Eq, Hash)]312pub struct ExprArrayComp {313 pub(crate) syntax: SyntaxNode,314}315impl ExprArrayComp {316 pub fn l_brack_token(&self) -> Option<SyntaxToken> {317 support::token(&self.syntax, T!['['])318 }319 pub fn expr(&self) -> Option<Expr> {320 support::children(&self.syntax).next()321 }322 pub fn comma_token(&self) -> Option<SyntaxToken> {323 support::token(&self.syntax, T![,])324 }325 pub fn comp_specs(&self) -> AstChildren<CompSpec> {326 support::children(&self.syntax)327 }328 pub fn r_brack_token(&self) -> Option<SyntaxToken> {329 support::token(&self.syntax, T![']'])330 }331}332333#[derive(Debug, Clone, PartialEq, Eq, Hash)]334pub struct ExprImport {335 pub(crate) syntax: SyntaxNode,336}337impl ExprImport {338 pub fn import_kind(&self) -> Option<ImportKind> {339 support::token_child(&self.syntax)340 }341 pub fn text(&self) -> Option<Text> {342 support::token_child(&self.syntax)343 }344}345346#[derive(Debug, Clone, PartialEq, Eq, Hash)]347pub struct ExprVar {348 pub(crate) syntax: SyntaxNode,349}350impl ExprVar {351 pub fn name(&self) -> Option<Name> {352 support::children(&self.syntax).next()353 }354}355356#[derive(Debug, Clone, PartialEq, Eq, Hash)]357pub struct ExprIfThenElse {358 pub(crate) syntax: SyntaxNode,359}360impl ExprIfThenElse {361 pub fn if_kw_token(&self) -> Option<SyntaxToken> {362 support::token(&self.syntax, T![if])363 }364 pub fn cond(&self) -> Option<Expr> {365 support::children(&self.syntax).next()366 }367 pub fn then_kw_token(&self) -> Option<SyntaxToken> {368 support::token(&self.syntax, T![then])369 }370 pub fn then(&self) -> Option<TrueExpr> {371 support::children(&self.syntax).next()372 }373 pub fn else_kw_token(&self) -> Option<SyntaxToken> {374 support::token(&self.syntax, T![else])375 }376 pub fn else_(&self) -> Option<FalseExpr> {377 support::children(&self.syntax).next()378 }379}380381#[derive(Debug, Clone, PartialEq, Eq, Hash)]382pub struct TrueExpr {383 pub(crate) syntax: SyntaxNode,384}385impl TrueExpr {386 pub fn expr(&self) -> Option<Expr> {387 support::children(&self.syntax).next()388 }389}390391#[derive(Debug, Clone, PartialEq, Eq, Hash)]392pub struct FalseExpr {393 pub(crate) syntax: SyntaxNode,394}395impl FalseExpr {396 pub fn expr(&self) -> Option<Expr> {397 support::children(&self.syntax).next()398 }399}400401#[derive(Debug, Clone, PartialEq, Eq, Hash)]402pub struct ExprFunction {403 pub(crate) syntax: SyntaxNode,404}405impl ExprFunction {406 pub fn function_kw_token(&self) -> Option<SyntaxToken> {407 support::token(&self.syntax, T![function])408 }409 pub fn l_paren_token(&self) -> Option<SyntaxToken> {410 support::token(&self.syntax, T!['('])411 }412 pub fn params_desc(&self) -> Option<ParamsDesc> {413 support::children(&self.syntax).next()414 }415 pub fn r_paren_token(&self) -> Option<SyntaxToken> {416 support::token(&self.syntax, T![')'])417 }418 pub fn expr(&self) -> Option<Expr> {419 support::children(&self.syntax).next()420 }421}422423#[derive(Debug, Clone, PartialEq, Eq, Hash)]424pub struct ParamsDesc {425 pub(crate) syntax: SyntaxNode,426}427impl ParamsDesc {428 pub fn l_paren_token(&self) -> Option<SyntaxToken> {429 support::token(&self.syntax, T!['('])430 }431 pub fn params(&self) -> AstChildren<Param> {432 support::children(&self.syntax)433 }434 pub fn r_paren_token(&self) -> Option<SyntaxToken> {435 support::token(&self.syntax, T![')'])436 }437}438439#[derive(Debug, Clone, PartialEq, Eq, Hash)]440pub struct ExprError {441 pub(crate) syntax: SyntaxNode,442}443impl ExprError {444 pub fn error_kw_token(&self) -> Option<SyntaxToken> {445 support::token(&self.syntax, T![error])446 }447 pub fn expr(&self) -> Option<Expr> {448 support::children(&self.syntax).next()449 }450}451452#[derive(Debug, Clone, PartialEq, Eq, Hash)]453pub struct SliceDescEnd {454 pub(crate) syntax: SyntaxNode,455}456impl SliceDescEnd {457 pub fn expr(&self) -> Option<Expr> {458 support::children(&self.syntax).next()459 }460}461462#[derive(Debug, Clone, PartialEq, Eq, Hash)]463pub struct SliceDescStep {464 pub(crate) syntax: SyntaxNode,465}466impl SliceDescStep {467 pub fn expr(&self) -> Option<Expr> {468 support::children(&self.syntax).next()469 }470}471472#[derive(Debug, Clone, PartialEq, Eq, Hash)]473pub struct Arg {474 pub(crate) syntax: SyntaxNode,475}476impl Arg {477 pub fn name(&self) -> Option<Name> {478 support::children(&self.syntax).next()479 }480 pub fn assign_token(&self) -> Option<SyntaxToken> {481 support::token(&self.syntax, T![=])482 }483 pub fn expr(&self) -> Option<Expr> {484 support::children(&self.syntax).next()485 }486}487488#[derive(Debug, Clone, PartialEq, Eq, Hash)]489pub struct ObjBodyComp {490 pub(crate) syntax: SyntaxNode,491}492impl ObjBodyComp {493 pub fn l_brace_token(&self) -> Option<SyntaxToken> {494 support::token(&self.syntax, T!['{'])495 }496 pub fn member_comps(&self) -> AstChildren<MemberComp> {497 support::children(&self.syntax)498 }499 pub fn comp_specs(&self) -> AstChildren<CompSpec> {500 support::children(&self.syntax)501 }502 pub fn r_brace_token(&self) -> Option<SyntaxToken> {503 support::token(&self.syntax, T!['}'])504 }505}506507#[derive(Debug, Clone, PartialEq, Eq, Hash)]508pub struct ObjBodyMemberList {509 pub(crate) syntax: SyntaxNode,510}511impl ObjBodyMemberList {512 pub fn l_brace_token(&self) -> Option<SyntaxToken> {513 support::token(&self.syntax, T!['{'])514 }515 pub fn members(&self) -> AstChildren<Member> {516 support::children(&self.syntax)517 }518 pub fn r_brace_token(&self) -> Option<SyntaxToken> {519 support::token(&self.syntax, T!['}'])520 }521}522523#[derive(Debug, Clone, PartialEq, Eq, Hash)]524pub struct MemberBindStmt {525 pub(crate) syntax: SyntaxNode,526}527impl MemberBindStmt {528 pub fn obj_local(&self) -> Option<ObjLocal> {529 support::children(&self.syntax).next()530 }531}532533#[derive(Debug, Clone, PartialEq, Eq, Hash)]534pub struct ObjLocal {535 pub(crate) syntax: SyntaxNode,536}537impl ObjLocal {538 pub fn local_kw_token(&self) -> Option<SyntaxToken> {539 support::token(&self.syntax, T![local])540 }541 pub fn bind(&self) -> Option<Bind> {542 support::children(&self.syntax).next()543 }544}545546#[derive(Debug, Clone, PartialEq, Eq, Hash)]547pub struct MemberAssertStmt {548 pub(crate) syntax: SyntaxNode,549}550impl MemberAssertStmt {551 pub fn assertion(&self) -> Option<Assertion> {552 support::children(&self.syntax).next()553 }554}555556#[derive(Debug, Clone, PartialEq, Eq, Hash)]557pub struct MemberFieldNormal {558 pub(crate) syntax: SyntaxNode,559}560impl MemberFieldNormal {561 pub fn field_name(&self) -> Option<FieldName> {562 support::children(&self.syntax).next()563 }564 pub fn plus_token(&self) -> Option<SyntaxToken> {565 support::token(&self.syntax, T![+])566 }567 pub fn visibility(&self) -> Option<Visibility> {568 support::children(&self.syntax).next()569 }570 pub fn expr(&self) -> Option<Expr> {571 support::children(&self.syntax).next()572 }573}574575#[derive(Debug, Clone, PartialEq, Eq, Hash)]576pub struct Visibility {577 pub(crate) syntax: SyntaxNode,578}579impl Visibility {580 pub fn colon_token(&self) -> Option<SyntaxToken> {581 support::token(&self.syntax, T![:])582 }583}584585#[derive(Debug, Clone, PartialEq, Eq, Hash)]586pub struct MemberFieldMethod {587 pub(crate) syntax: SyntaxNode,588}589impl MemberFieldMethod {590 pub fn field_name(&self) -> Option<FieldName> {591 support::children(&self.syntax).next()592 }593 pub fn params_desc(&self) -> Option<ParamsDesc> {594 support::children(&self.syntax).next()595 }596 pub fn visibility(&self) -> Option<Visibility> {597 support::children(&self.syntax).next()598 }599 pub fn expr(&self) -> Option<Expr> {600 support::children(&self.syntax).next()601 }602}603604#[derive(Debug, Clone, PartialEq, Eq, Hash)]605pub struct FieldNameFixed {606 pub(crate) syntax: SyntaxNode,607}608impl FieldNameFixed {609 pub fn id(&self) -> Option<Name> {610 support::children(&self.syntax).next()611 }612 pub fn text(&self) -> Option<Text> {613 support::token_child(&self.syntax)614 }615}616617#[derive(Debug, Clone, PartialEq, Eq, Hash)]618pub struct FieldNameDynamic {619 pub(crate) syntax: SyntaxNode,620}621impl FieldNameDynamic {622 pub fn l_brack_token(&self) -> Option<SyntaxToken> {623 support::token(&self.syntax, T!['['])624 }625 pub fn expr(&self) -> Option<Expr> {626 support::children(&self.syntax).next()627 }628 pub fn r_brack_token(&self) -> Option<SyntaxToken> {629 support::token(&self.syntax, T![']'])630 }631}632633#[derive(Debug, Clone, PartialEq, Eq, Hash)]634pub struct ForSpec {635 pub(crate) syntax: SyntaxNode,636}637impl ForSpec {638 pub fn for_kw_token(&self) -> Option<SyntaxToken> {639 support::token(&self.syntax, T![for])640 }641 pub fn bind(&self) -> Option<Destruct> {642 support::children(&self.syntax).next()643 }644 pub fn in_kw_token(&self) -> Option<SyntaxToken> {645 support::token(&self.syntax, T![in])646 }647 pub fn expr(&self) -> Option<Expr> {648 support::children(&self.syntax).next()649 }650}651652#[derive(Debug, Clone, PartialEq, Eq, Hash)]653pub struct ForObjSpec {654 pub(crate) syntax: SyntaxNode,655}656impl ForObjSpec {657 pub fn for_kw_token(&self) -> Option<SyntaxToken> {658 support::token(&self.syntax, T![for])659 }660 pub fn l_brack_token(&self) -> Option<SyntaxToken> {661 support::token(&self.syntax, T!['['])662 }663 pub fn key(&self) -> Option<Name> {664 support::children(&self.syntax).next()665 }666 pub fn r_brack_token(&self) -> Option<SyntaxToken> {667 support::token(&self.syntax, T![']'])668 }669 pub fn visibility(&self) -> Option<Visibility> {670 support::children(&self.syntax).next()671 }672 pub fn value(&self) -> Option<Destruct> {673 support::children(&self.syntax).next()674 }675 pub fn in_kw_token(&self) -> Option<SyntaxToken> {676 support::token(&self.syntax, T![in])677 }678 pub fn expr(&self) -> Option<Expr> {679 support::children(&self.syntax).next()680 }681}682683#[derive(Debug, Clone, PartialEq, Eq, Hash)]684pub struct IfSpec {685 pub(crate) syntax: SyntaxNode,686}687impl IfSpec {688 pub fn if_kw_token(&self) -> Option<SyntaxToken> {689 support::token(&self.syntax, T![if])690 }691 pub fn expr(&self) -> Option<Expr> {692 support::children(&self.syntax).next()693 }694}695696#[derive(Debug, Clone, PartialEq, Eq, Hash)]697pub struct BindDestruct {698 pub(crate) syntax: SyntaxNode,699}700impl BindDestruct {701 pub fn into(&self) -> Option<Destruct> {702 support::children(&self.syntax).next()703 }704 pub fn assign_token(&self) -> Option<SyntaxToken> {705 support::token(&self.syntax, T![=])706 }707 pub fn value(&self) -> Option<Expr> {708 support::children(&self.syntax).next()709 }710}711712#[derive(Debug, Clone, PartialEq, Eq, Hash)]713pub struct BindFunction {714 pub(crate) syntax: SyntaxNode,715}716impl BindFunction {717 pub fn name(&self) -> Option<Name> {718 support::children(&self.syntax).next()719 }720 pub fn params(&self) -> Option<ParamsDesc> {721 support::children(&self.syntax).next()722 }723 pub fn assign_token(&self) -> Option<SyntaxToken> {724 support::token(&self.syntax, T![=])725 }726 pub fn value(&self) -> Option<Expr> {727 support::children(&self.syntax).next()728 }729}730731#[derive(Debug, Clone, PartialEq, Eq, Hash)]732pub struct Param {733 pub(crate) syntax: SyntaxNode,734}735impl Param {736 pub fn destruct(&self) -> Option<Destruct> {737 support::children(&self.syntax).next()738 }739 pub fn assign_token(&self) -> Option<SyntaxToken> {740 support::token(&self.syntax, T![=])741 }742 pub fn expr(&self) -> Option<Expr> {743 support::children(&self.syntax).next()744 }745}746747#[derive(Debug, Clone, PartialEq, Eq, Hash)]748pub struct DestructFull {749 pub(crate) syntax: SyntaxNode,750}751impl DestructFull {752 pub fn name(&self) -> Option<Name> {753 support::children(&self.syntax).next()754 }755}756757#[derive(Debug, Clone, PartialEq, Eq, Hash)]758pub struct DestructSkip {759 pub(crate) syntax: SyntaxNode,760}761impl DestructSkip {762 pub fn question_mark_token(&self) -> Option<SyntaxToken> {763 support::token(&self.syntax, T![?])764 }765}766767#[derive(Debug, Clone, PartialEq, Eq, Hash)]768pub struct DestructArray {769 pub(crate) syntax: SyntaxNode,770}771impl DestructArray {772 pub fn l_brack_token(&self) -> Option<SyntaxToken> {773 support::token(&self.syntax, T!['['])774 }775 pub fn destruct_array_parts(&self) -> AstChildren<DestructArrayPart> {776 support::children(&self.syntax)777 }778 pub fn r_brack_token(&self) -> Option<SyntaxToken> {779 support::token(&self.syntax, T![']'])780 }781}782783#[derive(Debug, Clone, PartialEq, Eq, Hash)]784pub struct DestructObject {785 pub(crate) syntax: SyntaxNode,786}787impl DestructObject {788 pub fn l_brace_token(&self) -> Option<SyntaxToken> {789 support::token(&self.syntax, T!['{'])790 }791 pub fn destruct_object_fields(&self) -> AstChildren<DestructObjectField> {792 support::children(&self.syntax)793 }794 pub fn destruct_rest(&self) -> Option<DestructRest> {795 support::children(&self.syntax).next()796 }797 pub fn comma_token(&self) -> Option<SyntaxToken> {798 support::token(&self.syntax, T![,])799 }800 pub fn r_brace_token(&self) -> Option<SyntaxToken> {801 support::token(&self.syntax, T!['}'])802 }803}804805#[derive(Debug, Clone, PartialEq, Eq, Hash)]806pub struct DestructObjectField {807 pub(crate) syntax: SyntaxNode,808}809impl DestructObjectField {810 pub fn field(&self) -> Option<Name> {811 support::children(&self.syntax).next()812 }813 pub fn colon_token(&self) -> Option<SyntaxToken> {814 support::token(&self.syntax, T![:])815 }816 pub fn destruct(&self) -> Option<Destruct> {817 support::children(&self.syntax).next()818 }819 pub fn assign_token(&self) -> Option<SyntaxToken> {820 support::token(&self.syntax, T![=])821 }822 pub fn expr(&self) -> Option<Expr> {823 support::children(&self.syntax).next()824 }825}826827#[derive(Debug, Clone, PartialEq, Eq, Hash)]828pub struct DestructRest {829 pub(crate) syntax: SyntaxNode,830}831impl DestructRest {832 pub fn dotdotdot_token(&self) -> Option<SyntaxToken> {833 support::token(&self.syntax, T![...])834 }835 pub fn into(&self) -> Option<Name> {836 support::children(&self.syntax).next()837 }838}839840#[derive(Debug, Clone, PartialEq, Eq, Hash)]841pub struct DestructArrayElement {842 pub(crate) syntax: SyntaxNode,843}844impl DestructArrayElement {845 pub fn destruct(&self) -> Option<Destruct> {846 support::children(&self.syntax).next()847 }848}849850#[derive(Debug, Clone, PartialEq, Eq, Hash)]851pub enum Suffix {852 SuffixIndex(SuffixIndex),853 SuffixIndexExpr(SuffixIndexExpr),854 SuffixSlice(SuffixSlice),855 SuffixApply(SuffixApply),856}857858#[derive(Debug, Clone, PartialEq, Eq, Hash)]859pub enum Bind {860 BindDestruct(BindDestruct),861 BindFunction(BindFunction),862}863864#[derive(Debug, Clone, PartialEq, Eq, Hash)]865pub enum Stmt {866 StmtLocal(StmtLocal),867 StmtAssert(StmtAssert),868}869870#[derive(Debug, Clone, PartialEq, Eq, Hash)]871pub enum ObjBody {872 ObjBodyComp(ObjBodyComp),873 ObjBodyMemberList(ObjBodyMemberList),874}875876#[derive(Debug, Clone, PartialEq, Eq, Hash)]877pub enum CompSpec {878 ForSpec(ForSpec),879 ForObjSpec(ForObjSpec),880 IfSpec(IfSpec),881}882883#[derive(Debug, Clone, PartialEq, Eq, Hash)]884pub enum ExprBase {885 ExprBinary(ExprBinary),886 ExprUnary(ExprUnary),887 ExprObjExtend(ExprObjExtend),888 ExprParened(ExprParened),889 ExprString(ExprString),890 ExprNumber(ExprNumber),891 ExprLiteral(ExprLiteral),892 ExprArray(ExprArray),893 ExprObject(ExprObject),894 ExprArrayComp(ExprArrayComp),895 ExprImport(ExprImport),896 ExprVar(ExprVar),897 ExprIfThenElse(ExprIfThenElse),898 ExprFunction(ExprFunction),899 ExprError(ExprError),900}901902#[derive(Debug, Clone, PartialEq, Eq, Hash)]903pub enum MemberComp {904 MemberBindStmt(MemberBindStmt),905 MemberFieldNormal(MemberFieldNormal),906 MemberFieldMethod(MemberFieldMethod),907}908909#[derive(Debug, Clone, PartialEq, Eq, Hash)]910pub enum Member {911 MemberBindStmt(MemberBindStmt),912 MemberAssertStmt(MemberAssertStmt),913 MemberFieldNormal(MemberFieldNormal),914 MemberFieldMethod(MemberFieldMethod),915}916917#[derive(Debug, Clone, PartialEq, Eq, Hash)]918pub enum FieldName {919 FieldNameFixed(FieldNameFixed),920 FieldNameDynamic(FieldNameDynamic),921}922923#[derive(Debug, Clone, PartialEq, Eq, Hash)]924pub enum Destruct {925 DestructFull(DestructFull),926 DestructSkip(DestructSkip),927 DestructArray(DestructArray),928 DestructObject(DestructObject),929}930931#[derive(Debug, Clone, PartialEq, Eq, Hash)]932pub enum DestructArrayPart {933 DestructArrayElement(DestructArrayElement),934 DestructRest(DestructRest),935}936937#[derive(Debug, Clone, PartialEq, Eq, Hash)]938pub struct BinaryOperator {939 syntax: SyntaxToken,940 kind: BinaryOperatorKind,941}942943#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]944pub enum BinaryOperatorKind {945 Or,946 NullCoaelse,947 And,948 BitOr,949 BitXor,950 BitAnd,951 Eq,952 Ne,953 Lt,954 Gt,955 Le,956 Ge,957 InKw,958 Lhs,959 Rhs,960 Plus,961 Minus,962 Mul,963 Div,964 Modulo,965 MetaObjectApply,966 ErrorNoOperator,967}968969#[derive(Debug, Clone, PartialEq, Eq, Hash)]970pub struct UnaryOperator {971 syntax: SyntaxToken,972 kind: UnaryOperatorKind,973}974975#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]976pub enum UnaryOperatorKind {977 Minus,978 Not,979 BitNot,980}981982#[derive(Debug, Clone, PartialEq, Eq, Hash)]983pub struct Literal {984 syntax: SyntaxToken,985 kind: LiteralKind,986}987988#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]989pub enum LiteralKind {990 NullKw,991 TrueKw,992 FalseKw,993 SelfKw,994 Dollar,995 SuperKw,996}997998#[derive(Debug, Clone, PartialEq, Eq, Hash)]999pub struct Text {1000 syntax: SyntaxToken,1001 kind: TextKind,1002}10031004#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]1005pub enum TextKind {1006 StringDouble,1007 ErrorStringDoubleUnterminated,1008 StringSingle,1009 ErrorStringSingleUnterminated,1010 StringDoubleVerbatim,1011 ErrorStringDoubleVerbatimUnterminated,1012 StringSingleVerbatim,1013 ErrorStringSingleVerbatimUnterminated,1014 ErrorStringVerbatimMissingQuotes,1015 StringBlock,1016 ErrorStringBlockUnexpectedEnd,1017 ErrorStringBlockMissingNewLine,1018 ErrorStringBlockMissingTermination,1019 ErrorStringBlockMissingIndent,1020}10211022#[derive(Debug, Clone, PartialEq, Eq, Hash)]1023pub struct Number {1024 syntax: SyntaxToken,1025 kind: NumberKind,1026}10271028#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]1029pub enum NumberKind {1030 Float,1031 ErrorFloatJunkAfterPoint,1032 ErrorFloatJunkAfterExponent,1033 ErrorFloatJunkAfterExponentSign,1034}10351036#[derive(Debug, Clone, PartialEq, Eq, Hash)]1037pub struct ImportKind {1038 syntax: SyntaxToken,1039 kind: ImportKindKind,1040}10411042#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]1043pub enum ImportKindKind {1044 ImportstrKw,1045 ImportbinKw,1046 ImportKw,1047}10481049#[derive(Debug, Clone, PartialEq, Eq, Hash)]1050pub struct Trivia {1051 syntax: SyntaxToken,1052 kind: TriviaKind,1053}10541055#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]1056pub enum TriviaKind {1057 Whitespace,1058 MultiLineComment,1059 ErrorCommentTooShort,1060 ErrorCommentUnterminated,1061 SingleLineHashComment,1062 SingleLineSlashComment,1063}10641065#[derive(Debug, Clone, PartialEq, Eq, Hash)]1066pub struct CustomError {1067 syntax: SyntaxToken,1068 kind: CustomErrorKind,1069}10701071#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]1072pub enum CustomErrorKind {1073 ErrorMissingToken,1074 ErrorUnexpectedToken,1075 ErrorCustom,1076}1077impl AstNode for SourceFile {1078 fn can_cast(kind: SyntaxKind) -> bool {1079 kind == SOURCE_FILE1080 }1081 fn cast(syntax: SyntaxNode) -> Option<Self> {1082 if Self::can_cast(syntax.kind()) {1083 Some(Self { syntax })1084 } else {1085 None1086 }1087 }1088 fn syntax(&self) -> &SyntaxNode {1089 &self.syntax1090 }1091}1092impl AstNode for Expr {1093 fn can_cast(kind: SyntaxKind) -> bool {1094 kind == EXPR1095 }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 SuffixIndex {1108 fn can_cast(kind: SyntaxKind) -> bool {1109 kind == SUFFIX_INDEX1110 }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 Name {1123 fn can_cast(kind: SyntaxKind) -> bool {1124 kind == NAME1125 }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 SuffixIndexExpr {1138 fn can_cast(kind: SyntaxKind) -> bool {1139 kind == SUFFIX_INDEX_EXPR1140 }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 SuffixSlice {1153 fn can_cast(kind: SyntaxKind) -> bool {1154 kind == SUFFIX_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 SuffixApply {1183 fn can_cast(kind: SyntaxKind) -> bool {1184 kind == SUFFIX_APPLY1185 }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 ArgsDesc {1198 fn can_cast(kind: SyntaxKind) -> bool {1199 kind == ARGS_DESC1200 }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 StmtLocal {1213 fn can_cast(kind: SyntaxKind) -> bool {1214 kind == STMT_LOCAL1215 }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 StmtAssert {1228 fn can_cast(kind: SyntaxKind) -> bool {1229 kind == STMT_ASSERT1230 }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 Assertion {1243 fn can_cast(kind: SyntaxKind) -> bool {1244 kind == ASSERTION1245 }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 ExprBinary {1258 fn can_cast(kind: SyntaxKind) -> bool {1259 kind == EXPR_BINARY1260 }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 ExprUnary {1273 fn can_cast(kind: SyntaxKind) -> bool {1274 kind == EXPR_UNARY1275 }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 ExprObjExtend {1288 fn can_cast(kind: SyntaxKind) -> bool {1289 kind == EXPR_OBJ_EXTEND1290 }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 ExprParened {1303 fn can_cast(kind: SyntaxKind) -> bool {1304 kind == EXPR_PARENED1305 }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 ExprLiteral {1318 fn can_cast(kind: SyntaxKind) -> bool {1319 kind == EXPR_LITERAL1320 }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 ExprString {1333 fn can_cast(kind: SyntaxKind) -> bool {1334 kind == EXPR_STRING1335 }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 ExprNumber {1348 fn can_cast(kind: SyntaxKind) -> bool {1349 kind == EXPR_NUMBER1350 }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 ExprArray {1363 fn can_cast(kind: SyntaxKind) -> bool {1364 kind == EXPR_ARRAY1365 }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 ExprObject {1378 fn can_cast(kind: SyntaxKind) -> bool {1379 kind == EXPR_OBJECT1380 }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 ExprArrayComp {1393 fn can_cast(kind: SyntaxKind) -> bool {1394 kind == EXPR_ARRAY_COMP1395 }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 ExprImport {1408 fn can_cast(kind: SyntaxKind) -> bool {1409 kind == EXPR_IMPORT1410 }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 ExprVar {1423 fn can_cast(kind: SyntaxKind) -> bool {1424 kind == EXPR_VAR1425 }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 ExprIfThenElse {1438 fn can_cast(kind: SyntaxKind) -> bool {1439 kind == EXPR_IF_THEN_ELSE1440 }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 TrueExpr {1453 fn can_cast(kind: SyntaxKind) -> bool {1454 kind == TRUE_EXPR1455 }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 FalseExpr {1468 fn can_cast(kind: SyntaxKind) -> bool {1469 kind == FALSE_EXPR1470 }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 ExprFunction {1483 fn can_cast(kind: SyntaxKind) -> bool {1484 kind == EXPR_FUNCTION1485 }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 ParamsDesc {1498 fn can_cast(kind: SyntaxKind) -> bool {1499 kind == PARAMS_DESC1500 }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 ExprError {1513 fn can_cast(kind: SyntaxKind) -> bool {1514 kind == EXPR_ERROR1515 }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 SliceDescEnd {1528 fn can_cast(kind: SyntaxKind) -> bool {1529 kind == SLICE_DESC_END1530 }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 SliceDescStep {1543 fn can_cast(kind: SyntaxKind) -> bool {1544 kind == SLICE_DESC_STEP1545 }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 Arg {1558 fn can_cast(kind: SyntaxKind) -> bool {1559 kind == ARG1560 }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 ObjBodyComp {1573 fn can_cast(kind: SyntaxKind) -> bool {1574 kind == OBJ_BODY_COMP1575 }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 ObjBodyMemberList {1588 fn can_cast(kind: SyntaxKind) -> bool {1589 kind == OBJ_BODY_MEMBER_LIST1590 }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 MemberBindStmt {1603 fn can_cast(kind: SyntaxKind) -> bool {1604 kind == MEMBER_BIND_STMT1605 }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 ObjLocal {1618 fn can_cast(kind: SyntaxKind) -> bool {1619 kind == OBJ_LOCAL1620 }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 MemberAssertStmt {1633 fn can_cast(kind: SyntaxKind) -> bool {1634 kind == MEMBER_ASSERT_STMT1635 }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 MemberFieldNormal {1648 fn can_cast(kind: SyntaxKind) -> bool {1649 kind == MEMBER_FIELD_NORMAL1650 }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 Visibility {1663 fn can_cast(kind: SyntaxKind) -> bool {1664 kind == VISIBILITY1665 }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 MemberFieldMethod {1678 fn can_cast(kind: SyntaxKind) -> bool {1679 kind == MEMBER_FIELD_METHOD1680 }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 FieldNameFixed {1693 fn can_cast(kind: SyntaxKind) -> bool {1694 kind == FIELD_NAME_FIXED1695 }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 FieldNameDynamic {1708 fn can_cast(kind: SyntaxKind) -> bool {1709 kind == FIELD_NAME_DYNAMIC1710 }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 ForSpec {1723 fn can_cast(kind: SyntaxKind) -> bool {1724 kind == FOR_SPEC1725 }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 ForObjSpec {1738 fn can_cast(kind: SyntaxKind) -> bool {1739 kind == FOR_OBJ_SPEC1740 }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 IfSpec {1753 fn can_cast(kind: SyntaxKind) -> bool {1754 kind == IF_SPEC1755 }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 BindDestruct {1768 fn can_cast(kind: SyntaxKind) -> bool {1769 kind == BIND_DESTRUCT1770 }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 BindFunction {1783 fn can_cast(kind: SyntaxKind) -> bool {1784 kind == BIND_FUNCTION1785 }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 Param {1798 fn can_cast(kind: SyntaxKind) -> bool {1799 kind == PARAM1800 }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 DestructFull {1813 fn can_cast(kind: SyntaxKind) -> bool {1814 kind == DESTRUCT_FULL1815 }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 DestructSkip {1828 fn can_cast(kind: SyntaxKind) -> bool {1829 kind == DESTRUCT_SKIP1830 }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 DestructArray {1843 fn can_cast(kind: SyntaxKind) -> bool {1844 kind == DESTRUCT_ARRAY1845 }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 DestructObject {1858 fn can_cast(kind: SyntaxKind) -> bool {1859 kind == DESTRUCT_OBJECT1860 }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 DestructObjectField {1873 fn can_cast(kind: SyntaxKind) -> bool {1874 kind == DESTRUCT_OBJECT_FIELD1875 }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 DestructRest {1888 fn can_cast(kind: SyntaxKind) -> bool {1889 kind == DESTRUCT_REST1890 }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 DestructArrayElement {1903 fn can_cast(kind: SyntaxKind) -> bool {1904 kind == DESTRUCT_ARRAY_ELEMENT1905 }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 From<SuffixIndex> for Suffix {1918 fn from(node: SuffixIndex) -> Suffix {1919 Suffix::SuffixIndex(node)1920 }1921}1922impl From<SuffixIndexExpr> for Suffix {1923 fn from(node: SuffixIndexExpr) -> Suffix {1924 Suffix::SuffixIndexExpr(node)1925 }1926}1927impl From<SuffixSlice> for Suffix {1928 fn from(node: SuffixSlice) -> Suffix {1929 Suffix::SuffixSlice(node)1930 }1931}1932impl From<SuffixApply> for Suffix {1933 fn from(node: SuffixApply) -> Suffix {1934 Suffix::SuffixApply(node)1935 }1936}1937impl AstNode for Suffix {1938 fn can_cast(kind: SyntaxKind) -> bool {1939 match kind {1940 SUFFIX_INDEX | SUFFIX_INDEX_EXPR | SUFFIX_SLICE | SUFFIX_APPLY => true,1941 _ => false,1942 }1943 }1944 fn cast(syntax: SyntaxNode) -> Option<Self> {1945 let res = match syntax.kind() {1946 SUFFIX_INDEX => Suffix::SuffixIndex(SuffixIndex { syntax }),1947 SUFFIX_INDEX_EXPR => Suffix::SuffixIndexExpr(SuffixIndexExpr { syntax }),1948 SUFFIX_SLICE => Suffix::SuffixSlice(SuffixSlice { syntax }),1949 SUFFIX_APPLY => Suffix::SuffixApply(SuffixApply { syntax }),1950 _ => return None,1951 };1952 Some(res)1953 }1954 fn syntax(&self) -> &SyntaxNode {1955 match self {1956 Suffix::SuffixIndex(it) => &it.syntax,1957 Suffix::SuffixIndexExpr(it) => &it.syntax,1958 Suffix::SuffixSlice(it) => &it.syntax,1959 Suffix::SuffixApply(it) => &it.syntax,1960 }1961 }1962}1963impl From<BindDestruct> for Bind {1964 fn from(node: BindDestruct) -> Bind {1965 Bind::BindDestruct(node)1966 }1967}1968impl From<BindFunction> for Bind {1969 fn from(node: BindFunction) -> Bind {1970 Bind::BindFunction(node)1971 }1972}1973impl AstNode for Bind {1974 fn can_cast(kind: SyntaxKind) -> bool {1975 match kind {1976 BIND_DESTRUCT | BIND_FUNCTION => true,1977 _ => false,1978 }1979 }1980 fn cast(syntax: SyntaxNode) -> Option<Self> {1981 let res = match syntax.kind() {1982 BIND_DESTRUCT => Bind::BindDestruct(BindDestruct { syntax }),1983 BIND_FUNCTION => Bind::BindFunction(BindFunction { syntax }),1984 _ => return None,1985 };1986 Some(res)1987 }1988 fn syntax(&self) -> &SyntaxNode {1989 match self {1990 Bind::BindDestruct(it) => &it.syntax,1991 Bind::BindFunction(it) => &it.syntax,1992 }1993 }1994}1995impl From<StmtLocal> for Stmt {1996 fn from(node: StmtLocal) -> Stmt {1997 Stmt::StmtLocal(node)1998 }1999}2000impl From<StmtAssert> for Stmt {2001 fn from(node: StmtAssert) -> Stmt {2002 Stmt::StmtAssert(node)2003 }2004}2005impl AstNode for Stmt {2006 fn can_cast(kind: SyntaxKind) -> bool {2007 match kind {2008 STMT_LOCAL | STMT_ASSERT => true,2009 _ => false,2010 }2011 }2012 fn cast(syntax: SyntaxNode) -> Option<Self> {2013 let res = match syntax.kind() {2014 STMT_LOCAL => Stmt::StmtLocal(StmtLocal { syntax }),2015 STMT_ASSERT => Stmt::StmtAssert(StmtAssert { syntax }),2016 _ => return None,2017 };2018 Some(res)2019 }2020 fn syntax(&self) -> &SyntaxNode {2021 match self {2022 Stmt::StmtLocal(it) => &it.syntax,2023 Stmt::StmtAssert(it) => &it.syntax,2024 }2025 }2026}2027impl From<ObjBodyComp> for ObjBody {2028 fn from(node: ObjBodyComp) -> ObjBody {2029 ObjBody::ObjBodyComp(node)2030 }2031}2032impl From<ObjBodyMemberList> for ObjBody {2033 fn from(node: ObjBodyMemberList) -> ObjBody {2034 ObjBody::ObjBodyMemberList(node)2035 }2036}2037impl AstNode for ObjBody {2038 fn can_cast(kind: SyntaxKind) -> bool {2039 match kind {2040 OBJ_BODY_COMP | OBJ_BODY_MEMBER_LIST => true,2041 _ => false,2042 }2043 }2044 fn cast(syntax: SyntaxNode) -> Option<Self> {2045 let res = match syntax.kind() {2046 OBJ_BODY_COMP => ObjBody::ObjBodyComp(ObjBodyComp { syntax }),2047 OBJ_BODY_MEMBER_LIST => ObjBody::ObjBodyMemberList(ObjBodyMemberList { syntax }),2048 _ => return None,2049 };2050 Some(res)2051 }2052 fn syntax(&self) -> &SyntaxNode {2053 match self {2054 ObjBody::ObjBodyComp(it) => &it.syntax,2055 ObjBody::ObjBodyMemberList(it) => &it.syntax,2056 }2057 }2058}2059impl From<ForSpec> for CompSpec {2060 fn from(node: ForSpec) -> CompSpec {2061 CompSpec::ForSpec(node)2062 }2063}2064impl From<ForObjSpec> for CompSpec {2065 fn from(node: ForObjSpec) -> CompSpec {2066 CompSpec::ForObjSpec(node)2067 }2068}2069impl From<IfSpec> for CompSpec {2070 fn from(node: IfSpec) -> CompSpec {2071 CompSpec::IfSpec(node)2072 }2073}2074impl AstNode for CompSpec {2075 fn can_cast(kind: SyntaxKind) -> bool {2076 match kind {2077 FOR_SPEC | FOR_OBJ_SPEC | IF_SPEC => true,2078 _ => false,2079 }2080 }2081 fn cast(syntax: SyntaxNode) -> Option<Self> {2082 let res = match syntax.kind() {2083 FOR_SPEC => CompSpec::ForSpec(ForSpec { syntax }),2084 FOR_OBJ_SPEC => CompSpec::ForObjSpec(ForObjSpec { syntax }),2085 IF_SPEC => CompSpec::IfSpec(IfSpec { syntax }),2086 _ => return None,2087 };2088 Some(res)2089 }2090 fn syntax(&self) -> &SyntaxNode {2091 match self {2092 CompSpec::ForSpec(it) => &it.syntax,2093 CompSpec::ForObjSpec(it) => &it.syntax,2094 CompSpec::IfSpec(it) => &it.syntax,2095 }2096 }2097}2098impl From<ExprBinary> for ExprBase {2099 fn from(node: ExprBinary) -> ExprBase {2100 ExprBase::ExprBinary(node)2101 }2102}2103impl From<ExprUnary> for ExprBase {2104 fn from(node: ExprUnary) -> ExprBase {2105 ExprBase::ExprUnary(node)2106 }2107}2108impl From<ExprObjExtend> for ExprBase {2109 fn from(node: ExprObjExtend) -> ExprBase {2110 ExprBase::ExprObjExtend(node)2111 }2112}2113impl From<ExprParened> for ExprBase {2114 fn from(node: ExprParened) -> ExprBase {2115 ExprBase::ExprParened(node)2116 }2117}2118impl From<ExprString> for ExprBase {2119 fn from(node: ExprString) -> ExprBase {2120 ExprBase::ExprString(node)2121 }2122}2123impl From<ExprNumber> for ExprBase {2124 fn from(node: ExprNumber) -> ExprBase {2125 ExprBase::ExprNumber(node)2126 }2127}2128impl From<ExprLiteral> for ExprBase {2129 fn from(node: ExprLiteral) -> ExprBase {2130 ExprBase::ExprLiteral(node)2131 }2132}2133impl From<ExprArray> for ExprBase {2134 fn from(node: ExprArray) -> ExprBase {2135 ExprBase::ExprArray(node)2136 }2137}2138impl From<ExprObject> for ExprBase {2139 fn from(node: ExprObject) -> ExprBase {2140 ExprBase::ExprObject(node)2141 }2142}2143impl From<ExprArrayComp> for ExprBase {2144 fn from(node: ExprArrayComp) -> ExprBase {2145 ExprBase::ExprArrayComp(node)2146 }2147}2148impl From<ExprImport> for ExprBase {2149 fn from(node: ExprImport) -> ExprBase {2150 ExprBase::ExprImport(node)2151 }2152}2153impl From<ExprVar> for ExprBase {2154 fn from(node: ExprVar) -> ExprBase {2155 ExprBase::ExprVar(node)2156 }2157}2158impl From<ExprIfThenElse> for ExprBase {2159 fn from(node: ExprIfThenElse) -> ExprBase {2160 ExprBase::ExprIfThenElse(node)2161 }2162}2163impl From<ExprFunction> for ExprBase {2164 fn from(node: ExprFunction) -> ExprBase {2165 ExprBase::ExprFunction(node)2166 }2167}2168impl From<ExprError> for ExprBase {2169 fn from(node: ExprError) -> ExprBase {2170 ExprBase::ExprError(node)2171 }2172}2173impl AstNode for ExprBase {2174 fn can_cast(kind: SyntaxKind) -> bool {2175 match kind {2176 EXPR_BINARY | EXPR_UNARY | EXPR_OBJ_EXTEND | EXPR_PARENED | EXPR_STRING2177 | EXPR_NUMBER | EXPR_LITERAL | EXPR_ARRAY | EXPR_OBJECT | EXPR_ARRAY_COMP2178 | EXPR_IMPORT | EXPR_VAR | EXPR_IF_THEN_ELSE | EXPR_FUNCTION | EXPR_ERROR => true,2179 _ => false,2180 }2181 }2182 fn cast(syntax: SyntaxNode) -> Option<Self> {2183 let res = match syntax.kind() {2184 EXPR_BINARY => ExprBase::ExprBinary(ExprBinary { syntax }),2185 EXPR_UNARY => ExprBase::ExprUnary(ExprUnary { syntax }),2186 EXPR_OBJ_EXTEND => ExprBase::ExprObjExtend(ExprObjExtend { syntax }),2187 EXPR_PARENED => ExprBase::ExprParened(ExprParened { syntax }),2188 EXPR_STRING => ExprBase::ExprString(ExprString { syntax }),2189 EXPR_NUMBER => ExprBase::ExprNumber(ExprNumber { syntax }),2190 EXPR_LITERAL => ExprBase::ExprLiteral(ExprLiteral { syntax }),2191 EXPR_ARRAY => ExprBase::ExprArray(ExprArray { syntax }),2192 EXPR_OBJECT => ExprBase::ExprObject(ExprObject { syntax }),2193 EXPR_ARRAY_COMP => ExprBase::ExprArrayComp(ExprArrayComp { syntax }),2194 EXPR_IMPORT => ExprBase::ExprImport(ExprImport { syntax }),2195 EXPR_VAR => ExprBase::ExprVar(ExprVar { syntax }),2196 EXPR_IF_THEN_ELSE => ExprBase::ExprIfThenElse(ExprIfThenElse { syntax }),2197 EXPR_FUNCTION => ExprBase::ExprFunction(ExprFunction { syntax }),2198 EXPR_ERROR => ExprBase::ExprError(ExprError { syntax }),2199 _ => return None,2200 };2201 Some(res)2202 }2203 fn syntax(&self) -> &SyntaxNode {2204 match self {2205 ExprBase::ExprBinary(it) => &it.syntax,2206 ExprBase::ExprUnary(it) => &it.syntax,2207 ExprBase::ExprObjExtend(it) => &it.syntax,2208 ExprBase::ExprParened(it) => &it.syntax,2209 ExprBase::ExprString(it) => &it.syntax,2210 ExprBase::ExprNumber(it) => &it.syntax,2211 ExprBase::ExprLiteral(it) => &it.syntax,2212 ExprBase::ExprArray(it) => &it.syntax,2213 ExprBase::ExprObject(it) => &it.syntax,2214 ExprBase::ExprArrayComp(it) => &it.syntax,2215 ExprBase::ExprImport(it) => &it.syntax,2216 ExprBase::ExprVar(it) => &it.syntax,2217 ExprBase::ExprIfThenElse(it) => &it.syntax,2218 ExprBase::ExprFunction(it) => &it.syntax,2219 ExprBase::ExprError(it) => &it.syntax,2220 }2221 }2222}2223impl From<MemberBindStmt> for MemberComp {2224 fn from(node: MemberBindStmt) -> MemberComp {2225 MemberComp::MemberBindStmt(node)2226 }2227}2228impl From<MemberFieldNormal> for MemberComp {2229 fn from(node: MemberFieldNormal) -> MemberComp {2230 MemberComp::MemberFieldNormal(node)2231 }2232}2233impl From<MemberFieldMethod> for MemberComp {2234 fn from(node: MemberFieldMethod) -> MemberComp {2235 MemberComp::MemberFieldMethod(node)2236 }2237}2238impl AstNode for MemberComp {2239 fn can_cast(kind: SyntaxKind) -> bool {2240 match kind {2241 MEMBER_BIND_STMT | MEMBER_FIELD_NORMAL | MEMBER_FIELD_METHOD => true,2242 _ => false,2243 }2244 }2245 fn cast(syntax: SyntaxNode) -> Option<Self> {2246 let res = match syntax.kind() {2247 MEMBER_BIND_STMT => MemberComp::MemberBindStmt(MemberBindStmt { syntax }),2248 MEMBER_FIELD_NORMAL => MemberComp::MemberFieldNormal(MemberFieldNormal { syntax }),2249 MEMBER_FIELD_METHOD => MemberComp::MemberFieldMethod(MemberFieldMethod { syntax }),2250 _ => return None,2251 };2252 Some(res)2253 }2254 fn syntax(&self) -> &SyntaxNode {2255 match self {2256 MemberComp::MemberBindStmt(it) => &it.syntax,2257 MemberComp::MemberFieldNormal(it) => &it.syntax,2258 MemberComp::MemberFieldMethod(it) => &it.syntax,2259 }2260 }2261}2262impl From<MemberBindStmt> for Member {2263 fn from(node: MemberBindStmt) -> Member {2264 Member::MemberBindStmt(node)2265 }2266}2267impl From<MemberAssertStmt> for Member {2268 fn from(node: MemberAssertStmt) -> Member {2269 Member::MemberAssertStmt(node)2270 }2271}2272impl From<MemberFieldNormal> for Member {2273 fn from(node: MemberFieldNormal) -> Member {2274 Member::MemberFieldNormal(node)2275 }2276}2277impl From<MemberFieldMethod> for Member {2278 fn from(node: MemberFieldMethod) -> Member {2279 Member::MemberFieldMethod(node)2280 }2281}2282impl AstNode for Member {2283 fn can_cast(kind: SyntaxKind) -> bool {2284 match kind {2285 MEMBER_BIND_STMT | MEMBER_ASSERT_STMT | MEMBER_FIELD_NORMAL | MEMBER_FIELD_METHOD => {2286 true2287 }2288 _ => false,2289 }2290 }2291 fn cast(syntax: SyntaxNode) -> Option<Self> {2292 let res = match syntax.kind() {2293 MEMBER_BIND_STMT => Member::MemberBindStmt(MemberBindStmt { syntax }),2294 MEMBER_ASSERT_STMT => Member::MemberAssertStmt(MemberAssertStmt { syntax }),2295 MEMBER_FIELD_NORMAL => Member::MemberFieldNormal(MemberFieldNormal { syntax }),2296 MEMBER_FIELD_METHOD => Member::MemberFieldMethod(MemberFieldMethod { syntax }),2297 _ => return None,2298 };2299 Some(res)2300 }2301 fn syntax(&self) -> &SyntaxNode {2302 match self {2303 Member::MemberBindStmt(it) => &it.syntax,2304 Member::MemberAssertStmt(it) => &it.syntax,2305 Member::MemberFieldNormal(it) => &it.syntax,2306 Member::MemberFieldMethod(it) => &it.syntax,2307 }2308 }2309}2310impl From<FieldNameFixed> for FieldName {2311 fn from(node: FieldNameFixed) -> FieldName {2312 FieldName::FieldNameFixed(node)2313 }2314}2315impl From<FieldNameDynamic> for FieldName {2316 fn from(node: FieldNameDynamic) -> FieldName {2317 FieldName::FieldNameDynamic(node)2318 }2319}2320impl AstNode for FieldName {2321 fn can_cast(kind: SyntaxKind) -> bool {2322 match kind {2323 FIELD_NAME_FIXED | FIELD_NAME_DYNAMIC => true,2324 _ => false,2325 }2326 }2327 fn cast(syntax: SyntaxNode) -> Option<Self> {2328 let res = match syntax.kind() {2329 FIELD_NAME_FIXED => FieldName::FieldNameFixed(FieldNameFixed { syntax }),2330 FIELD_NAME_DYNAMIC => FieldName::FieldNameDynamic(FieldNameDynamic { syntax }),2331 _ => return None,2332 };2333 Some(res)2334 }2335 fn syntax(&self) -> &SyntaxNode {2336 match self {2337 FieldName::FieldNameFixed(it) => &it.syntax,2338 FieldName::FieldNameDynamic(it) => &it.syntax,2339 }2340 }2341}2342impl From<DestructFull> for Destruct {2343 fn from(node: DestructFull) -> Destruct {2344 Destruct::DestructFull(node)2345 }2346}2347impl From<DestructSkip> for Destruct {2348 fn from(node: DestructSkip) -> Destruct {2349 Destruct::DestructSkip(node)2350 }2351}2352impl From<DestructArray> for Destruct {2353 fn from(node: DestructArray) -> Destruct {2354 Destruct::DestructArray(node)2355 }2356}2357impl From<DestructObject> for Destruct {2358 fn from(node: DestructObject) -> Destruct {2359 Destruct::DestructObject(node)2360 }2361}2362impl AstNode for Destruct {2363 fn can_cast(kind: SyntaxKind) -> bool {2364 match kind {2365 DESTRUCT_FULL | DESTRUCT_SKIP | DESTRUCT_ARRAY | DESTRUCT_OBJECT => true,2366 _ => false,2367 }2368 }2369 fn cast(syntax: SyntaxNode) -> Option<Self> {2370 let res = match syntax.kind() {2371 DESTRUCT_FULL => Destruct::DestructFull(DestructFull { syntax }),2372 DESTRUCT_SKIP => Destruct::DestructSkip(DestructSkip { syntax }),2373 DESTRUCT_ARRAY => Destruct::DestructArray(DestructArray { syntax }),2374 DESTRUCT_OBJECT => Destruct::DestructObject(DestructObject { syntax }),2375 _ => return None,2376 };2377 Some(res)2378 }2379 fn syntax(&self) -> &SyntaxNode {2380 match self {2381 Destruct::DestructFull(it) => &it.syntax,2382 Destruct::DestructSkip(it) => &it.syntax,2383 Destruct::DestructArray(it) => &it.syntax,2384 Destruct::DestructObject(it) => &it.syntax,2385 }2386 }2387}2388impl From<DestructArrayElement> for DestructArrayPart {2389 fn from(node: DestructArrayElement) -> DestructArrayPart {2390 DestructArrayPart::DestructArrayElement(node)2391 }2392}2393impl From<DestructRest> for DestructArrayPart {2394 fn from(node: DestructRest) -> DestructArrayPart {2395 DestructArrayPart::DestructRest(node)2396 }2397}2398impl AstNode for DestructArrayPart {2399 fn can_cast(kind: SyntaxKind) -> bool {2400 match kind {2401 DESTRUCT_ARRAY_ELEMENT | DESTRUCT_REST => true,2402 _ => false,2403 }2404 }2405 fn cast(syntax: SyntaxNode) -> Option<Self> {2406 let res = match syntax.kind() {2407 DESTRUCT_ARRAY_ELEMENT => {2408 DestructArrayPart::DestructArrayElement(DestructArrayElement { syntax })2409 }2410 DESTRUCT_REST => DestructArrayPart::DestructRest(DestructRest { syntax }),2411 _ => return None,2412 };2413 Some(res)2414 }2415 fn syntax(&self) -> &SyntaxNode {2416 match self {2417 DestructArrayPart::DestructArrayElement(it) => &it.syntax,2418 DestructArrayPart::DestructRest(it) => &it.syntax,2419 }2420 }2421}2422impl AstToken for BinaryOperator {2423 fn can_cast(kind: SyntaxKind) -> bool {2424 BinaryOperatorKind::can_cast(kind)2425 }2426 fn cast(syntax: SyntaxToken) -> Option<Self> {2427 let kind = BinaryOperatorKind::cast(syntax.kind())?;2428 Some(BinaryOperator { syntax, kind })2429 }2430 fn syntax(&self) -> &SyntaxToken {2431 &self.syntax2432 }2433}2434impl BinaryOperatorKind {2435 fn can_cast(kind: SyntaxKind) -> bool {2436 match kind {2437 OR | NULL_COAELSE | AND | BIT_OR | BIT_XOR | BIT_AND | EQ | NE | LT | GT | LE | GE2438 | IN_KW | LHS | RHS | PLUS | MINUS | MUL | DIV | MODULO | META_OBJECT_APPLY2439 | ERROR_NO_OPERATOR => true,2440 _ => false,2441 }2442 }2443 pub fn cast(kind: SyntaxKind) -> Option<Self> {2444 let res = match kind {2445 OR => Self::Or,2446 NULL_COAELSE => Self::NullCoaelse,2447 AND => Self::And,2448 BIT_OR => Self::BitOr,2449 BIT_XOR => Self::BitXor,2450 BIT_AND => Self::BitAnd,2451 EQ => Self::Eq,2452 NE => Self::Ne,2453 LT => Self::Lt,2454 GT => Self::Gt,2455 LE => Self::Le,2456 GE => Self::Ge,2457 IN_KW => Self::InKw,2458 LHS => Self::Lhs,2459 RHS => Self::Rhs,2460 PLUS => Self::Plus,2461 MINUS => Self::Minus,2462 MUL => Self::Mul,2463 DIV => Self::Div,2464 MODULO => Self::Modulo,2465 META_OBJECT_APPLY => Self::MetaObjectApply,2466 ERROR_NO_OPERATOR => Self::ErrorNoOperator,2467 _ => return None,2468 };2469 Some(res)2470 }2471}2472impl BinaryOperator {2473 pub fn kind(&self) -> BinaryOperatorKind {2474 self.kind2475 }2476}2477impl std::fmt::Display for BinaryOperator {2478 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2479 std::fmt::Display::fmt(self.syntax(), f)2480 }2481}2482impl AstToken for UnaryOperator {2483 fn can_cast(kind: SyntaxKind) -> bool {2484 UnaryOperatorKind::can_cast(kind)2485 }2486 fn cast(syntax: SyntaxToken) -> Option<Self> {2487 let kind = UnaryOperatorKind::cast(syntax.kind())?;2488 Some(UnaryOperator { syntax, kind })2489 }2490 fn syntax(&self) -> &SyntaxToken {2491 &self.syntax2492 }2493}2494impl UnaryOperatorKind {2495 fn can_cast(kind: SyntaxKind) -> bool {2496 match kind {2497 MINUS | NOT | BIT_NOT => true,2498 _ => false,2499 }2500 }2501 pub fn cast(kind: SyntaxKind) -> Option<Self> {2502 let res = match kind {2503 MINUS => Self::Minus,2504 NOT => Self::Not,2505 BIT_NOT => Self::BitNot,2506 _ => return None,2507 };2508 Some(res)2509 }2510}2511impl UnaryOperator {2512 pub fn kind(&self) -> UnaryOperatorKind {2513 self.kind2514 }2515}2516impl std::fmt::Display for UnaryOperator {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 Literal {2522 fn can_cast(kind: SyntaxKind) -> bool {2523 LiteralKind::can_cast(kind)2524 }2525 fn cast(syntax: SyntaxToken) -> Option<Self> {2526 let kind = LiteralKind::cast(syntax.kind())?;2527 Some(Literal { syntax, kind })2528 }2529 fn syntax(&self) -> &SyntaxToken {2530 &self.syntax2531 }2532}2533impl LiteralKind {2534 fn can_cast(kind: SyntaxKind) -> bool {2535 match kind {2536 NULL_KW | TRUE_KW | FALSE_KW | SELF_KW | DOLLAR | SUPER_KW => true,2537 _ => false,2538 }2539 }2540 pub fn cast(kind: SyntaxKind) -> Option<Self> {2541 let res = match kind {2542 NULL_KW => Self::NullKw,2543 TRUE_KW => Self::TrueKw,2544 FALSE_KW => Self::FalseKw,2545 SELF_KW => Self::SelfKw,2546 DOLLAR => Self::Dollar,2547 SUPER_KW => Self::SuperKw,2548 _ => return None,2549 };2550 Some(res)2551 }2552}2553impl Literal {2554 pub fn kind(&self) -> LiteralKind {2555 self.kind2556 }2557}2558impl std::fmt::Display for Literal {2559 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2560 std::fmt::Display::fmt(self.syntax(), f)2561 }2562}2563impl AstToken for Text {2564 fn can_cast(kind: SyntaxKind) -> bool {2565 TextKind::can_cast(kind)2566 }2567 fn cast(syntax: SyntaxToken) -> Option<Self> {2568 let kind = TextKind::cast(syntax.kind())?;2569 Some(Text { syntax, kind })2570 }2571 fn syntax(&self) -> &SyntaxToken {2572 &self.syntax2573 }2574}2575impl TextKind {2576 fn can_cast(kind: SyntaxKind) -> bool {2577 match kind {2578 STRING_DOUBLE2579 | ERROR_STRING_DOUBLE_UNTERMINATED2580 | STRING_SINGLE2581 | ERROR_STRING_SINGLE_UNTERMINATED2582 | STRING_DOUBLE_VERBATIM2583 | ERROR_STRING_DOUBLE_VERBATIM_UNTERMINATED2584 | STRING_SINGLE_VERBATIM2585 | ERROR_STRING_SINGLE_VERBATIM_UNTERMINATED2586 | ERROR_STRING_VERBATIM_MISSING_QUOTES2587 | STRING_BLOCK2588 | ERROR_STRING_BLOCK_UNEXPECTED_END2589 | ERROR_STRING_BLOCK_MISSING_NEW_LINE2590 | ERROR_STRING_BLOCK_MISSING_TERMINATION2591 | ERROR_STRING_BLOCK_MISSING_INDENT => true,2592 _ => false,2593 }2594 }2595 pub fn cast(kind: SyntaxKind) -> Option<Self> {2596 let res = match kind {2597 STRING_DOUBLE => Self::StringDouble,2598 ERROR_STRING_DOUBLE_UNTERMINATED => Self::ErrorStringDoubleUnterminated,2599 STRING_SINGLE => Self::StringSingle,2600 ERROR_STRING_SINGLE_UNTERMINATED => Self::ErrorStringSingleUnterminated,2601 STRING_DOUBLE_VERBATIM => Self::StringDoubleVerbatim,2602 ERROR_STRING_DOUBLE_VERBATIM_UNTERMINATED => {2603 Self::ErrorStringDoubleVerbatimUnterminated2604 }2605 STRING_SINGLE_VERBATIM => Self::StringSingleVerbatim,2606 ERROR_STRING_SINGLE_VERBATIM_UNTERMINATED => {2607 Self::ErrorStringSingleVerbatimUnterminated2608 }2609 ERROR_STRING_VERBATIM_MISSING_QUOTES => Self::ErrorStringVerbatimMissingQuotes,2610 STRING_BLOCK => Self::StringBlock,2611 ERROR_STRING_BLOCK_UNEXPECTED_END => Self::ErrorStringBlockUnexpectedEnd,2612 ERROR_STRING_BLOCK_MISSING_NEW_LINE => Self::ErrorStringBlockMissingNewLine,2613 ERROR_STRING_BLOCK_MISSING_TERMINATION => Self::ErrorStringBlockMissingTermination,2614 ERROR_STRING_BLOCK_MISSING_INDENT => Self::ErrorStringBlockMissingIndent,2615 _ => return None,2616 };2617 Some(res)2618 }2619}2620impl Text {2621 pub fn kind(&self) -> TextKind {2622 self.kind2623 }2624}2625impl std::fmt::Display for Text {2626 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2627 std::fmt::Display::fmt(self.syntax(), f)2628 }2629}2630impl AstToken for Number {2631 fn can_cast(kind: SyntaxKind) -> bool {2632 NumberKind::can_cast(kind)2633 }2634 fn cast(syntax: SyntaxToken) -> Option<Self> {2635 let kind = NumberKind::cast(syntax.kind())?;2636 Some(Number { syntax, kind })2637 }2638 fn syntax(&self) -> &SyntaxToken {2639 &self.syntax2640 }2641}2642impl NumberKind {2643 fn can_cast(kind: SyntaxKind) -> bool {2644 match kind {2645 FLOAT2646 | ERROR_FLOAT_JUNK_AFTER_POINT2647 | ERROR_FLOAT_JUNK_AFTER_EXPONENT2648 | ERROR_FLOAT_JUNK_AFTER_EXPONENT_SIGN => true,2649 _ => false,2650 }2651 }2652 pub fn cast(kind: SyntaxKind) -> Option<Self> {2653 let res = match kind {2654 FLOAT => Self::Float,2655 ERROR_FLOAT_JUNK_AFTER_POINT => Self::ErrorFloatJunkAfterPoint,2656 ERROR_FLOAT_JUNK_AFTER_EXPONENT => Self::ErrorFloatJunkAfterExponent,2657 ERROR_FLOAT_JUNK_AFTER_EXPONENT_SIGN => Self::ErrorFloatJunkAfterExponentSign,2658 _ => return None,2659 };2660 Some(res)2661 }2662}2663impl Number {2664 pub fn kind(&self) -> NumberKind {2665 self.kind2666 }2667}2668impl std::fmt::Display for Number {2669 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2670 std::fmt::Display::fmt(self.syntax(), f)2671 }2672}2673impl AstToken for ImportKind {2674 fn can_cast(kind: SyntaxKind) -> bool {2675 ImportKindKind::can_cast(kind)2676 }2677 fn cast(syntax: SyntaxToken) -> Option<Self> {2678 let kind = ImportKindKind::cast(syntax.kind())?;2679 Some(ImportKind { syntax, kind })2680 }2681 fn syntax(&self) -> &SyntaxToken {2682 &self.syntax2683 }2684}2685impl ImportKindKind {2686 fn can_cast(kind: SyntaxKind) -> bool {2687 match kind {2688 IMPORTSTR_KW | IMPORTBIN_KW | IMPORT_KW => true,2689 _ => false,2690 }2691 }2692 pub fn cast(kind: SyntaxKind) -> Option<Self> {2693 let res = match kind {2694 IMPORTSTR_KW => Self::ImportstrKw,2695 IMPORTBIN_KW => Self::ImportbinKw,2696 IMPORT_KW => Self::ImportKw,2697 _ => return None,2698 };2699 Some(res)2700 }2701}2702impl ImportKind {2703 pub fn kind(&self) -> ImportKindKind {2704 self.kind2705 }2706}2707impl std::fmt::Display for ImportKind {2708 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2709 std::fmt::Display::fmt(self.syntax(), f)2710 }2711}2712impl AstToken for Trivia {2713 fn can_cast(kind: SyntaxKind) -> bool {2714 TriviaKind::can_cast(kind)2715 }2716 fn cast(syntax: SyntaxToken) -> Option<Self> {2717 let kind = TriviaKind::cast(syntax.kind())?;2718 Some(Trivia { syntax, kind })2719 }2720 fn syntax(&self) -> &SyntaxToken {2721 &self.syntax2722 }2723}2724impl TriviaKind {2725 fn can_cast(kind: SyntaxKind) -> bool {2726 match kind {2727 WHITESPACE2728 | MULTI_LINE_COMMENT2729 | ERROR_COMMENT_TOO_SHORT2730 | ERROR_COMMENT_UNTERMINATED2731 | SINGLE_LINE_HASH_COMMENT2732 | SINGLE_LINE_SLASH_COMMENT => true,2733 _ => false,2734 }2735 }2736 pub fn cast(kind: SyntaxKind) -> Option<Self> {2737 let res = match kind {2738 WHITESPACE => Self::Whitespace,2739 MULTI_LINE_COMMENT => Self::MultiLineComment,2740 ERROR_COMMENT_TOO_SHORT => Self::ErrorCommentTooShort,2741 ERROR_COMMENT_UNTERMINATED => Self::ErrorCommentUnterminated,2742 SINGLE_LINE_HASH_COMMENT => Self::SingleLineHashComment,2743 SINGLE_LINE_SLASH_COMMENT => Self::SingleLineSlashComment,2744 _ => return None,2745 };2746 Some(res)2747 }2748}2749impl Trivia {2750 pub fn kind(&self) -> TriviaKind {2751 self.kind2752 }2753}2754impl std::fmt::Display for Trivia {2755 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2756 std::fmt::Display::fmt(self.syntax(), f)2757 }2758}2759impl AstToken for CustomError {2760 fn can_cast(kind: SyntaxKind) -> bool {2761 CustomErrorKind::can_cast(kind)2762 }2763 fn cast(syntax: SyntaxToken) -> Option<Self> {2764 let kind = CustomErrorKind::cast(syntax.kind())?;2765 Some(CustomError { syntax, kind })2766 }2767 fn syntax(&self) -> &SyntaxToken {2768 &self.syntax2769 }2770}2771impl CustomErrorKind {2772 fn can_cast(kind: SyntaxKind) -> bool {2773 match kind {2774 ERROR_MISSING_TOKEN | ERROR_UNEXPECTED_TOKEN | ERROR_CUSTOM => true,2775 _ => false,2776 }2777 }2778 pub fn cast(kind: SyntaxKind) -> Option<Self> {2779 let res = match kind {2780 ERROR_MISSING_TOKEN => Self::ErrorMissingToken,2781 ERROR_UNEXPECTED_TOKEN => Self::ErrorUnexpectedToken,2782 ERROR_CUSTOM => Self::ErrorCustom,2783 _ => return None,2784 };2785 Some(res)2786 }2787}2788impl CustomError {2789 pub fn kind(&self) -> CustomErrorKind {2790 self.kind2791 }2792}2793impl std::fmt::Display for CustomError {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 Suffix {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 Bind {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 Stmt {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 ObjBody {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 CompSpec {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 ExprBase {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 MemberComp {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 Member {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 FieldName {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 Destruct {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 DestructArrayPart {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 SourceFile {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 Expr {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 SuffixIndex {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 Name {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 SuffixIndexExpr {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 SuffixSlice {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 SliceDesc {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 SuffixApply {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 ArgsDesc {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 StmtLocal {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 StmtAssert {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 Assertion {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 ExprBinary {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 ExprUnary {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 ExprObjExtend {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 ExprParened {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 ExprLiteral {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 ExprString {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 ExprNumber {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 ExprArray {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 ExprObject {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 ExprArrayComp {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 ExprImport {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 ExprVar {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 ExprIfThenElse {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 TrueExpr {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 FalseExpr {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 ExprFunction {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 ParamsDesc {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 ExprError {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 SliceDescEnd {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 SliceDescStep {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 Arg {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 ObjBodyComp {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 ObjBodyMemberList {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 MemberBindStmt {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 ObjLocal {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 MemberAssertStmt {3039 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3040 std::fmt::Display::fmt(self.syntax(), f)3041 }3042}3043impl std::fmt::Display for MemberFieldNormal {3044 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3045 std::fmt::Display::fmt(self.syntax(), f)3046 }3047}3048impl std::fmt::Display for Visibility {3049 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3050 std::fmt::Display::fmt(self.syntax(), f)3051 }3052}3053impl std::fmt::Display for MemberFieldMethod {3054 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3055 std::fmt::Display::fmt(self.syntax(), f)3056 }3057}3058impl std::fmt::Display for FieldNameFixed {3059 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3060 std::fmt::Display::fmt(self.syntax(), f)3061 }3062}3063impl std::fmt::Display for FieldNameDynamic {3064 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3065 std::fmt::Display::fmt(self.syntax(), f)3066 }3067}3068impl std::fmt::Display for ForSpec {3069 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3070 std::fmt::Display::fmt(self.syntax(), f)3071 }3072}3073impl std::fmt::Display for ForObjSpec {3074 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3075 std::fmt::Display::fmt(self.syntax(), f)3076 }3077}3078impl std::fmt::Display for IfSpec {3079 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3080 std::fmt::Display::fmt(self.syntax(), f)3081 }3082}3083impl std::fmt::Display for BindDestruct {3084 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3085 std::fmt::Display::fmt(self.syntax(), f)3086 }3087}3088impl std::fmt::Display for BindFunction {3089 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3090 std::fmt::Display::fmt(self.syntax(), f)3091 }3092}3093impl std::fmt::Display for Param {3094 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3095 std::fmt::Display::fmt(self.syntax(), f)3096 }3097}3098impl std::fmt::Display for DestructFull {3099 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3100 std::fmt::Display::fmt(self.syntax(), f)3101 }3102}3103impl std::fmt::Display for DestructSkip {3104 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3105 std::fmt::Display::fmt(self.syntax(), f)3106 }3107}3108impl std::fmt::Display for DestructArray {3109 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3110 std::fmt::Display::fmt(self.syntax(), f)3111 }3112}3113impl std::fmt::Display for DestructObject {3114 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3115 std::fmt::Display::fmt(self.syntax(), f)3116 }3117}3118impl std::fmt::Display for DestructObjectField {3119 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3120 std::fmt::Display::fmt(self.syntax(), f)3121 }3122}3123impl std::fmt::Display for DestructRest {3124 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3125 std::fmt::Display::fmt(self.syntax(), f)3126 }3127}3128impl std::fmt::Display for DestructArrayElement {3129 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3130 std::fmt::Display::fmt(self.syntax(), f)3131 }3132}crates/jrsonnet-rowan-parser/src/generated/syntax_kinds.rsdiffbeforeafterboth--- a/crates/jrsonnet-rowan-parser/src/generated/syntax_kinds.rs
+++ b/crates/jrsonnet-rowan-parser/src/generated/syntax_kinds.rs
@@ -145,6 +145,7 @@
FIELD_NAME_FIXED,
FIELD_NAME_DYNAMIC,
FOR_SPEC,
+ FOR_OBJ_SPEC,
IF_SPEC,
BIND_DESTRUCT,
BIND_FUNCTION,
crates/jrsonnet-rowan-parser/src/parser.rsdiffbeforeafterboth--- a/crates/jrsonnet-rowan-parser/src/parser.rs
+++ b/crates/jrsonnet-rowan-parser/src/parser.rs
@@ -364,6 +364,19 @@
fn compspec(p: &mut Parser) -> CompletedMarker {
assert!(p.at_ts(COMPSPEC));
if p.at(T![for]) {
+ if p.nth_at(1, T!['[']) && p.nth_at(2, IDENT) && p.nth_at(3, T![']']) && p.nth_at(4, T![:])
+ {
+ let m = p.start();
+ p.bump_assert(T![for]);
+ p.bump_assert(T!['[']);
+ name(p);
+ p.expect(T![']']);
+ visibility(p);
+ destruct(p);
+ p.expect(T![in]);
+ expr(p);
+ return m.complete(p, FOR_OBJ_SPEC);
+ }
let m = p.start();
p.bump();
destruct(p);
crates/jrsonnet-rowan-parser/src/snapshots/jrsonnet_rowan_parser__tests__for_obj_spec_force_visible.snapdiffbeforeafterboth--- /dev/null
+++ b/crates/jrsonnet-rowan-parser/src/snapshots/jrsonnet_rowan_parser__tests__for_obj_spec_force_visible.snap
@@ -0,0 +1,51 @@
+---
+source: crates/jrsonnet-rowan-parser/src/tests.rs
+expression: "{ [k]: v for [k]::: v in obj }\n"
+---
+SOURCE_FILE@0..31
+ EXPR@0..30
+ EXPR_OBJECT@0..30
+ OBJ_BODY_COMP@0..30
+ L_BRACE@0..1 "{"
+ WHITESPACE@1..2 " "
+ MEMBER_FIELD_NORMAL@2..8
+ FIELD_NAME_DYNAMIC@2..5
+ L_BRACK@2..3 "["
+ EXPR@3..4
+ EXPR_VAR@3..4
+ NAME@3..4
+ IDENT@3..4 "k"
+ R_BRACK@4..5 "]"
+ VISIBILITY@5..6
+ COLON@5..6 ":"
+ WHITESPACE@6..7 " "
+ EXPR@7..8
+ EXPR_VAR@7..8
+ NAME@7..8
+ IDENT@7..8 "v"
+ WHITESPACE@8..9 " "
+ FOR_OBJ_SPEC@9..28
+ FOR_KW@9..12 "for"
+ WHITESPACE@12..13 " "
+ L_BRACK@13..14 "["
+ NAME@14..15
+ IDENT@14..15 "k"
+ R_BRACK@15..16 "]"
+ VISIBILITY@16..19
+ COLON@16..17 ":"
+ COLON@17..18 ":"
+ COLON@18..19 ":"
+ WHITESPACE@19..20 " "
+ DESTRUCT_FULL@20..21
+ NAME@20..21
+ IDENT@20..21 "v"
+ WHITESPACE@21..22 " "
+ IN_KW@22..24 "in"
+ WHITESPACE@24..25 " "
+ EXPR@25..28
+ EXPR_VAR@25..28
+ NAME@25..28
+ IDENT@25..28 "obj"
+ WHITESPACE@28..29 " "
+ R_BRACE@29..30 "}"
+ WHITESPACE@30..31 "\n"
crates/jrsonnet-rowan-parser/src/snapshots/jrsonnet_rowan_parser__tests__for_obj_spec_hidden.snapdiffbeforeafterboth--- /dev/null
+++ b/crates/jrsonnet-rowan-parser/src/snapshots/jrsonnet_rowan_parser__tests__for_obj_spec_hidden.snap
@@ -0,0 +1,50 @@
+---
+source: crates/jrsonnet-rowan-parser/src/tests.rs
+expression: "{ [k]: v for [k]:: v in obj }\n"
+---
+SOURCE_FILE@0..30
+ EXPR@0..29
+ EXPR_OBJECT@0..29
+ OBJ_BODY_COMP@0..29
+ L_BRACE@0..1 "{"
+ WHITESPACE@1..2 " "
+ MEMBER_FIELD_NORMAL@2..8
+ FIELD_NAME_DYNAMIC@2..5
+ L_BRACK@2..3 "["
+ EXPR@3..4
+ EXPR_VAR@3..4
+ NAME@3..4
+ IDENT@3..4 "k"
+ R_BRACK@4..5 "]"
+ VISIBILITY@5..6
+ COLON@5..6 ":"
+ WHITESPACE@6..7 " "
+ EXPR@7..8
+ EXPR_VAR@7..8
+ NAME@7..8
+ IDENT@7..8 "v"
+ WHITESPACE@8..9 " "
+ FOR_OBJ_SPEC@9..27
+ FOR_KW@9..12 "for"
+ WHITESPACE@12..13 " "
+ L_BRACK@13..14 "["
+ NAME@14..15
+ IDENT@14..15 "k"
+ R_BRACK@15..16 "]"
+ VISIBILITY@16..18
+ COLON@16..17 ":"
+ COLON@17..18 ":"
+ WHITESPACE@18..19 " "
+ DESTRUCT_FULL@19..20
+ NAME@19..20
+ IDENT@19..20 "v"
+ WHITESPACE@20..21 " "
+ IN_KW@21..23 "in"
+ WHITESPACE@23..24 " "
+ EXPR@24..27
+ EXPR_VAR@24..27
+ NAME@24..27
+ IDENT@24..27 "obj"
+ WHITESPACE@27..28 " "
+ R_BRACE@28..29 "}"
+ WHITESPACE@29..30 "\n"
crates/jrsonnet-rowan-parser/src/snapshots/jrsonnet_rowan_parser__tests__for_obj_spec_value_destruct.snapdiffbeforeafterboth--- /dev/null
+++ b/crates/jrsonnet-rowan-parser/src/snapshots/jrsonnet_rowan_parser__tests__for_obj_spec_value_destruct.snap
@@ -0,0 +1,66 @@
+---
+source: crates/jrsonnet-rowan-parser/src/tests.rs
+expression: "{ [k]: a + b for [k]: [a, b] in obj }\n"
+---
+SOURCE_FILE@0..38
+ EXPR@0..37
+ EXPR_OBJECT@0..37
+ OBJ_BODY_COMP@0..37
+ L_BRACE@0..1 "{"
+ WHITESPACE@1..2 " "
+ MEMBER_FIELD_NORMAL@2..12
+ FIELD_NAME_DYNAMIC@2..5
+ L_BRACK@2..3 "["
+ EXPR@3..4
+ EXPR_VAR@3..4
+ NAME@3..4
+ IDENT@3..4 "k"
+ R_BRACK@4..5 "]"
+ VISIBILITY@5..6
+ COLON@5..6 ":"
+ WHITESPACE@6..7 " "
+ EXPR@7..12
+ EXPR_BINARY@7..12
+ EXPR@7..8
+ EXPR_VAR@7..8
+ NAME@7..8
+ IDENT@7..8 "a"
+ WHITESPACE@8..9 " "
+ PLUS@9..10 "+"
+ WHITESPACE@10..11 " "
+ EXPR@11..12
+ EXPR_VAR@11..12
+ NAME@11..12
+ IDENT@11..12 "b"
+ WHITESPACE@12..13 " "
+ FOR_OBJ_SPEC@13..35
+ FOR_KW@13..16 "for"
+ WHITESPACE@16..17 " "
+ L_BRACK@17..18 "["
+ NAME@18..19
+ IDENT@18..19 "k"
+ R_BRACK@19..20 "]"
+ VISIBILITY@20..21
+ COLON@20..21 ":"
+ WHITESPACE@21..22 " "
+ DESTRUCT_ARRAY@22..28
+ L_BRACK@22..23 "["
+ DESTRUCT_FULL@23..24
+ NAME@23..24
+ IDENT@23..24 "a"
+ COMMA@24..25 ","
+ WHITESPACE@25..26 " "
+ DESTRUCT_FULL@26..27
+ NAME@26..27
+ IDENT@26..27 "b"
+ R_BRACK@27..28 "]"
+ WHITESPACE@28..29 " "
+ IN_KW@29..31 "in"
+ WHITESPACE@31..32 " "
+ EXPR@32..35
+ EXPR_VAR@32..35
+ NAME@32..35
+ IDENT@32..35 "obj"
+ WHITESPACE@35..36 " "
+ R_BRACE@36..37 "}"
+ WHITESPACE@37..38 "\n"
crates/jrsonnet-rowan-parser/src/snapshots/jrsonnet_rowan_parser__tests__for_obj_spec_visible.snapdiffbeforeafterboth--- /dev/null
+++ b/crates/jrsonnet-rowan-parser/src/snapshots/jrsonnet_rowan_parser__tests__for_obj_spec_visible.snap
@@ -0,0 +1,49 @@
+---
+source: crates/jrsonnet-rowan-parser/src/tests.rs
+expression: "{ [k]: v for [k]: v in obj }\n"
+---
+SOURCE_FILE@0..29
+ EXPR@0..28
+ EXPR_OBJECT@0..28
+ OBJ_BODY_COMP@0..28
+ L_BRACE@0..1 "{"
+ WHITESPACE@1..2 " "
+ MEMBER_FIELD_NORMAL@2..8
+ FIELD_NAME_DYNAMIC@2..5
+ L_BRACK@2..3 "["
+ EXPR@3..4
+ EXPR_VAR@3..4
+ NAME@3..4
+ IDENT@3..4 "k"
+ R_BRACK@4..5 "]"
+ VISIBILITY@5..6
+ COLON@5..6 ":"
+ WHITESPACE@6..7 " "
+ EXPR@7..8
+ EXPR_VAR@7..8
+ NAME@7..8
+ IDENT@7..8 "v"
+ WHITESPACE@8..9 " "
+ FOR_OBJ_SPEC@9..26
+ FOR_KW@9..12 "for"
+ WHITESPACE@12..13 " "
+ L_BRACK@13..14 "["
+ NAME@14..15
+ IDENT@14..15 "k"
+ R_BRACK@15..16 "]"
+ VISIBILITY@16..17
+ COLON@16..17 ":"
+ WHITESPACE@17..18 " "
+ DESTRUCT_FULL@18..19
+ NAME@18..19
+ IDENT@18..19 "v"
+ WHITESPACE@19..20 " "
+ IN_KW@20..22 "in"
+ WHITESPACE@22..23 " "
+ EXPR@23..26
+ EXPR_VAR@23..26
+ NAME@23..26
+ IDENT@23..26 "obj"
+ WHITESPACE@26..27 " "
+ R_BRACE@27..28 "}"
+ WHITESPACE@28..29 "\n"
crates/jrsonnet-rowan-parser/src/tests.rsdiffbeforeafterboth--- a/crates/jrsonnet-rowan-parser/src/tests.rs
+++ b/crates/jrsonnet-rowan-parser/src/tests.rs
@@ -228,6 +228,19 @@
local_in_binop_rhs => r#"
a + local x = 1; x
"#
+
+ for_obj_spec_visible => r#"
+ { [k]: v for [k]: v in obj }
+ "#
+ for_obj_spec_hidden => r#"
+ { [k]: v for [k]:: v in obj }
+ "#
+ for_obj_spec_force_visible => r#"
+ { [k]: v for [k]::: v in obj }
+ "#
+ for_obj_spec_value_destruct => r#"
+ { [k]: a + b for [k]: [a, b] in obj }
+ "#
);
#[test]