From 8bdbafe6af270999078da02831e6d7d9b09b5136 Mon Sep 17 00:00:00 2001 From: Micha Reiser Date: Thu, 11 Nov 2021 15:14:26 +0100 Subject: [PATCH] refactor(rslint_parser): Restructure simple statements (#1769) Renames and restructures the following statements as we agreed to in our new JS grammar (#1719): * BlockStatement: Rename node and rename `stmts` child to `statements` * DebuggerStatement: Rename node * EmptyStatement: Rename node * ExpressionStatement: Rename node, `expr` child to `expression`, and add optional trailing semicolon * ReturnStatement: Rename node, and rename 'value' child to 'argument' * LabeledStatement: Rename node, change type of `label` child to a token, and rename `stmt` child to `body` * WithStatement: * Rename node * inline "condition" (it's not a condition) * rename `condition` to `object` * rename `cons` to `body` * Add parser test --- crates/rome_formatter/src/cst.rs | 28 +- .../src/ts/class/class_declarator.rs | 2 +- crates/rome_formatter/src/ts/expr_or_block.rs | 2 +- .../rome_formatter/src/ts/statements/block.rs | 6 +- .../src/ts/statements/debugger_statement.rs | 4 +- .../src/ts/statements/empty_statement.rs | 4 +- .../src/ts/statements/expression_statement.rs | 6 +- .../src/ts/statements/label_statement.rs | 8 +- .../src/ts/statements/return_statement.rs | 12 +- .../src/ts/statements/statement.rs | 18 +- .../src/ts/statements/with_statement.rs | 21 +- .../rslint_parser/src/ast/generated/nodes.rs | 313 ++++++++++-------- crates/rslint_parser/src/syntax/decl.rs | 2 +- crates/rslint_parser/src/syntax/program.rs | 2 +- crates/rslint_parser/src/syntax/stmt.rs | 30 +- crates/rslint_parser/src/tests.rs | 41 ++- .../err/async_arrow_expr_await_parameter.rast | 4 +- .../inline/err/binary_expressions_err.rast | 6 +- .../err/binding_identifier_invalid.rast | 6 +- .../inline/err/bracket_expr_err.rast | 6 +- .../inline/err/conditional_expr_err.rast | 4 +- .../inline/err/export_decl_not_top_level.rast | 2 +- .../test_data/inline/err/for_stmt_err.rast | 2 +- .../err/formal_params_no_binding_element.rast | 2 +- .../inline/err/function_decl_err.rast | 14 +- .../test_data/inline/err/if_stmt_err.rast | 8 +- .../inline/err/import_call_no_arg.rast | 2 +- .../inline/err/import_decl_not_top_level.rast | 2 +- .../test_data/inline/err/import_no_meta.rast | 4 +- .../inline/err/invalid_arg_list.rast | 4 +- .../inline/err/invalid_method_recover.rast | 4 +- .../paren_or_arrow_expr_invalid_params.rast | 4 +- .../err/primary_expr_invalid_recovery.rast | 2 +- .../test_data/inline/err/return_stmt_err.rast | 4 +- .../test_data/inline/err/subscripts_err.rast | 2 +- .../test_data/inline/err/throw_stmt_err.rast | 2 +- .../test_data/inline/err/while_stmt_err.rast | 6 +- .../test_data/inline/ok/array_expr.rast | 12 +- .../inline/ok/arrow_expr_single_param.rast | 16 +- .../test_data/inline/ok/assign_expr.rast | 10 +- .../test_data/inline/ok/async_arrow_expr.rast | 6 +- .../inline/ok/async_function_expr.rast | 4 +- .../test_data/inline/ok/async_method.rast | 4 +- .../inline/ok/binary_expressions.rast | 18 +- .../test_data/inline/ok/block_stmt.rast | 14 +- .../test_data/inline/ok/bracket_expr.rast | 10 +- .../test_data/inline/ok/break_stmt.rast | 14 +- .../inline/ok/class_empty_element.rast | 30 +- .../test_data/inline/ok/class_expr.rast | 4 +- .../test_data/inline/ok/conditional_expr.rast | 4 +- .../test_data/inline/ok/continue_stmt.rast | 9 +- .../test_data/inline/ok/debugger_stmt.rast | 2 +- .../test_data/inline/ok/dot_expr.rast | 12 +- .../test_data/inline/ok/empty_stmt.rast | 2 +- .../test_data/inline/ok/for_stmt.rast | 8 +- .../test_data/inline/ok/function_decl.rast | 14 +- .../test_data/inline/ok/function_expr.rast | 4 +- .../test_data/inline/ok/grouping_expr.rast | 2 +- .../inline/ok/identifier_reference.rast | 6 +- .../test_data/inline/ok/if_stmt.rast | 14 +- .../test_data/inline/ok/import_call.rast | 2 +- .../test_data/inline/ok/import_meta.rast | 2 +- .../test_data/inline/ok/literals.rast | 14 +- .../test_data/inline/ok/method_getter.rast | 2 +- .../test_data/inline/ok/method_setter.rast | 2 +- .../test_data/inline/ok/new_exprs.rast | 12 +- .../inline/ok/object_expr_async_method.rast | 4 +- .../ok/object_expr_generator_method.rast | 2 +- .../inline/ok/object_expr_getter_setter.rast | 4 +- .../object_expr_getter_setter_computed.rast | 4 +- .../inline/ok/object_expr_method.rast | 2 +- .../inline/ok/paren_or_arrow_expr.rast | 16 +- .../test_data/inline/ok/post_update_expr.rast | 4 +- .../test_data/inline/ok/pre_update_expr.rast | 4 +- .../test_data/inline/ok/return_stmt.rast | 10 +- .../test_data/inline/ok/semicolons.rast | 4 +- .../test_data/inline/ok/sequence_expr.rast | 2 +- .../test_data/inline/ok/static_method.rast | 8 +- .../test_data/inline/ok/subscripts.rast | 4 +- .../test_data/inline/ok/this_expr.rast | 4 +- .../test_data/inline/ok/try_stmt.rast | 10 +- .../test_data/inline/ok/while_stmt.rast | 4 +- .../test_data/inline/ok/with_statement.js | 7 + .../test_data/inline/ok/with_statement.rast | 58 ++++ .../test_data/inline/ok/yield_expr.rast | 6 +- crates/rslint_syntax/src/generated.rs | 15 +- xtask/js.ungram | 73 ++-- xtask/src/codegen/kinds_src.rs | 15 +- 88 files changed, 626 insertions(+), 476 deletions(-) create mode 100644 crates/rslint_parser/test_data/inline/ok/with_statement.js create mode 100644 crates/rslint_parser/test_data/inline/ok/with_statement.rast diff --git a/crates/rome_formatter/src/cst.rs b/crates/rome_formatter/src/cst.rs index df1a38e9b84..02eb9fa614f 100644 --- a/crates/rome_formatter/src/cst.rs +++ b/crates/rome_formatter/src/cst.rs @@ -1,12 +1,12 @@ use crate::{token, FormatElement, FormatResult, Formatter, ToFormatElement}; use rslint_parser::ast::{ - ArgList, ArrayExpr, ArrayPattern, ArrowExpr, AssignPattern, BlockStmt, CallExpr, CaseClause, - CatchClause, ClassBody, ClassDecl, ClassProp, Condition, ConstructorParameters, ContinueStmt, - DebuggerStmt, Declarator, DefaultClause, DoWhileStmt, EmptyStmt, ExprStmt, Finalizer, FnDecl, - ForInStmt, ForStmt, ForStmtInit, ForStmtTest, ForStmtUpdate, Getter, IdentProp, IfStmt, - JsScript, LabelledStmt, Literal, LiteralProp, Name, NameRef, ObjectExpr, ParameterList, - ReturnStmt, SequenceExpr, Setter, SinglePattern, SwitchStmt, TryStmt, VarDecl, WhileStmt, - WithStmt, + ArgList, ArrayExpr, ArrayPattern, ArrowExpr, AssignPattern, CallExpr, CaseClause, CatchClause, + ClassBody, ClassDecl, ClassProp, Condition, ConstructorParameters, ContinueStmt, Declarator, + DefaultClause, DoWhileStmt, Finalizer, FnDecl, ForInStmt, ForStmt, ForStmtInit, ForStmtTest, + ForStmtUpdate, Getter, IdentProp, IfStmt, JsBlockStatement, JsDebuggerStatement, + JsEmptyStatement, JsExpressionStatement, JsLabeledStatement, JsReturnStatement, JsScript, + JsWithStatement, Literal, LiteralProp, Name, NameRef, ObjectExpr, ParameterList, SequenceExpr, + Setter, SinglePattern, SwitchStmt, TryStmt, VarDecl, WhileStmt, }; use rslint_parser::{AstNode, AstToken, SyntaxKind, SyntaxNode, SyntaxToken}; @@ -55,13 +55,13 @@ impl ToFormatElement for SyntaxNode { SyntaxKind::SEQUENCE_EXPR => SequenceExpr::cast(self.clone()) .unwrap() .to_format_element(formatter), - SyntaxKind::BLOCK_STMT => BlockStmt::cast(self.clone()) + SyntaxKind::JS_BLOCK_STATEMENT => JsBlockStatement::cast(self.clone()) .unwrap() .to_format_element(formatter), - SyntaxKind::EXPR_STMT => ExprStmt::cast(self.clone()) + SyntaxKind::JS_EXPRESSION_STATEMENT => JsExpressionStatement::cast(self.clone()) .unwrap() .to_format_element(formatter), - SyntaxKind::RETURN_STMT => ReturnStmt::cast(self.clone()) + SyntaxKind::JS_RETURN_STATEMENT => JsReturnStatement::cast(self.clone()) .unwrap() .to_format_element(formatter), SyntaxKind::IF_STMT => IfStmt::cast(self.clone()) @@ -82,7 +82,7 @@ impl ToFormatElement for SyntaxNode { SyntaxKind::FOR_STMT_UPDATE => ForStmtUpdate::cast(self.clone()) .unwrap() .to_format_element(formatter), - SyntaxKind::EMPTY_STMT => EmptyStmt::cast(self.clone()) + SyntaxKind::JS_EMPTY_STATEMENT => JsEmptyStatement::cast(self.clone()) .unwrap() .to_format_element(formatter), SyntaxKind::IDENT_PROP => IdentProp::cast(self.clone()) @@ -109,7 +109,7 @@ impl ToFormatElement for SyntaxNode { SyntaxKind::CONTINUE_STMT => ContinueStmt::cast(self.clone()) .unwrap() .to_format_element(formatter), - SyntaxKind::LABELLED_STMT => LabelledStmt::cast(self.clone()) + SyntaxKind::JS_LABELED_STATEMENT => JsLabeledStatement::cast(self.clone()) .unwrap() .to_format_element(formatter), SyntaxKind::TRY_STMT => TryStmt::cast(self.clone()) @@ -121,10 +121,10 @@ impl ToFormatElement for SyntaxNode { SyntaxKind::CATCH_CLAUSE => CatchClause::cast(self.clone()) .unwrap() .to_format_element(formatter), - SyntaxKind::WITH_STMT => WithStmt::cast(self.clone()) + SyntaxKind::JS_WITH_STATEMENT => JsWithStatement::cast(self.clone()) .unwrap() .to_format_element(formatter), - SyntaxKind::DEBUGGER_STMT => DebuggerStmt::cast(self.clone()) + SyntaxKind::JS_DEBUGGER_STATEMENT => JsDebuggerStatement::cast(self.clone()) .unwrap() .to_format_element(formatter), SyntaxKind::FOR_IN_STMT => ForInStmt::cast(self.clone()) diff --git a/crates/rome_formatter/src/ts/class/class_declarator.rs b/crates/rome_formatter/src/ts/class/class_declarator.rs index a590845fb32..9145ed183b8 100644 --- a/crates/rome_formatter/src/ts/class/class_declarator.rs +++ b/crates/rome_formatter/src/ts/class/class_declarator.rs @@ -50,7 +50,7 @@ impl ToFormatElement for ClassBody { impl ToFormatElement for ClassElement { fn to_format_element(&self, formatter: &Formatter) -> FormatResult { match self { - ClassElement::EmptyStmt(empty_statement) => { + ClassElement::JsEmptyStatement(empty_statement) => { empty_statement.to_format_element(formatter) } ClassElement::Method(method) => method.to_format_element(formatter), diff --git a/crates/rome_formatter/src/ts/expr_or_block.rs b/crates/rome_formatter/src/ts/expr_or_block.rs index e4f3171eee4..37754f78d53 100644 --- a/crates/rome_formatter/src/ts/expr_or_block.rs +++ b/crates/rome_formatter/src/ts/expr_or_block.rs @@ -4,7 +4,7 @@ use rslint_parser::ast::ExprOrBlock; impl ToFormatElement for ExprOrBlock { fn to_format_element(&self, formatter: &Formatter) -> FormatResult { match self { - ExprOrBlock::BlockStmt(block) => block.to_format_element(formatter), + ExprOrBlock::JsBlockStatement(block) => block.to_format_element(formatter), ExprOrBlock::JsAnyExpression(expr) => expr.to_format_element(formatter), } } diff --git a/crates/rome_formatter/src/ts/statements/block.rs b/crates/rome_formatter/src/ts/statements/block.rs index 6fe9d46fede..f65d078c391 100644 --- a/crates/rome_formatter/src/ts/statements/block.rs +++ b/crates/rome_formatter/src/ts/statements/block.rs @@ -1,4 +1,4 @@ -use rslint_parser::ast::{BlockStmt, IfStmt}; +use rslint_parser::ast::{IfStmt, JsBlockStatement}; use rslint_parser::AstNode; use crate::ts::statements::format_statements; @@ -7,9 +7,9 @@ use crate::{ ToFormatElement, }; -impl ToFormatElement for BlockStmt { +impl ToFormatElement for JsBlockStatement { fn to_format_element(&self, formatter: &Formatter) -> FormatResult { - let stmts = format_statements(self.stmts(), formatter); + let stmts = format_statements(self.statements(), formatter); // Formatting of curly braces for an: // * empty block: same line `{}`, diff --git a/crates/rome_formatter/src/ts/statements/debugger_statement.rs b/crates/rome_formatter/src/ts/statements/debugger_statement.rs index 943c33fb15e..90af928e8b5 100644 --- a/crates/rome_formatter/src/ts/statements/debugger_statement.rs +++ b/crates/rome_formatter/src/ts/statements/debugger_statement.rs @@ -1,7 +1,7 @@ use crate::{format_elements, token, FormatElement, FormatResult, Formatter, ToFormatElement}; -use rslint_parser::ast::DebuggerStmt; +use rslint_parser::ast::JsDebuggerStatement; -impl ToFormatElement for DebuggerStmt { +impl ToFormatElement for JsDebuggerStatement { fn to_format_element(&self, formatter: &Formatter) -> FormatResult { Ok(format_elements![ formatter.format_token(&self.debugger_token()?)?, diff --git a/crates/rome_formatter/src/ts/statements/empty_statement.rs b/crates/rome_formatter/src/ts/statements/empty_statement.rs index 17f7f94d515..7cb9f7b0591 100644 --- a/crates/rome_formatter/src/ts/statements/empty_statement.rs +++ b/crates/rome_formatter/src/ts/statements/empty_statement.rs @@ -1,7 +1,7 @@ use crate::{empty_element, FormatElement, FormatResult, Formatter, ToFormatElement}; -use rslint_parser::ast::EmptyStmt; +use rslint_parser::ast::JsEmptyStatement; -impl ToFormatElement for EmptyStmt { +impl ToFormatElement for JsEmptyStatement { fn to_format_element(&self, _formatter: &Formatter) -> FormatResult { Ok(empty_element()) } diff --git a/crates/rome_formatter/src/ts/statements/expression_statement.rs b/crates/rome_formatter/src/ts/statements/expression_statement.rs index bdb5a232e4e..28e2885a4dd 100644 --- a/crates/rome_formatter/src/ts/statements/expression_statement.rs +++ b/crates/rome_formatter/src/ts/statements/expression_statement.rs @@ -1,11 +1,11 @@ -use rslint_parser::ast::ExprStmt; +use rslint_parser::ast::JsExpressionStatement; use crate::{format_elements, token, FormatElement, FormatResult, Formatter, ToFormatElement}; -impl ToFormatElement for ExprStmt { +impl ToFormatElement for JsExpressionStatement { fn to_format_element(&self, formatter: &Formatter) -> FormatResult { Ok(format_elements![ - formatter.format_node(self.expr()?)?, + formatter.format_node(self.expression()?)?, token(";") ]) } diff --git a/crates/rome_formatter/src/ts/statements/label_statement.rs b/crates/rome_formatter/src/ts/statements/label_statement.rs index 83cbeabe505..05a3295276d 100644 --- a/crates/rome_formatter/src/ts/statements/label_statement.rs +++ b/crates/rome_formatter/src/ts/statements/label_statement.rs @@ -1,13 +1,13 @@ use crate::{ format_elements, space_token, FormatElement, FormatResult, Formatter, ToFormatElement, }; -use rslint_parser::ast::LabelledStmt; +use rslint_parser::ast::JsLabeledStatement; -impl ToFormatElement for LabelledStmt { +impl ToFormatElement for JsLabeledStatement { fn to_format_element(&self, formatter: &Formatter) -> FormatResult { - let label = formatter.format_node(self.label()?)?; - let statement = formatter.format_node(self.stmt()?)?; + let label = formatter.format_token(&self.label_token()?)?; let colon = formatter.format_token(&self.colon_token()?)?; + let statement = formatter.format_node(self.body()?)?; Ok(format_elements![label, colon, space_token(), statement]) } diff --git a/crates/rome_formatter/src/ts/statements/return_statement.rs b/crates/rome_formatter/src/ts/statements/return_statement.rs index 786827973ec..c8c9c11027e 100644 --- a/crates/rome_formatter/src/ts/statements/return_statement.rs +++ b/crates/rome_formatter/src/ts/statements/return_statement.rs @@ -1,14 +1,16 @@ use crate::{ concat_elements, space_token, token, FormatElement, FormatResult, Formatter, ToFormatElement, }; -use rslint_parser::ast::ReturnStmt; +use rslint_parser::ast::JsReturnStatement; -impl ToFormatElement for ReturnStmt { +impl ToFormatElement for JsReturnStatement { fn to_format_element(&self, formatter: &Formatter) -> FormatResult { - let mut tokens = vec![token("return")]; + let mut tokens = vec![formatter.format_token(&self.return_token()?)?]; - tokens.push(space_token()); - tokens.push(formatter.format_node(self.value()?)?); + if let Some(argument) = self.argument() { + tokens.push(space_token()); + tokens.push(formatter.format_node(argument)?); + } tokens.push(token(";")); diff --git a/crates/rome_formatter/src/ts/statements/statement.rs b/crates/rome_formatter/src/ts/statements/statement.rs index 289a134672f..cec1a860ef2 100644 --- a/crates/rome_formatter/src/ts/statements/statement.rs +++ b/crates/rome_formatter/src/ts/statements/statement.rs @@ -4,11 +4,13 @@ use rslint_parser::ast::JsAnyStatement; impl ToFormatElement for JsAnyStatement { fn to_format_element(&self, formatter: &Formatter) -> FormatResult { match self { - JsAnyStatement::BlockStmt(block) => block.to_format_element(formatter), - JsAnyStatement::EmptyStmt(empty_statement) => { + JsAnyStatement::JsBlockStatement(block) => block.to_format_element(formatter), + JsAnyStatement::JsEmptyStatement(empty_statement) => { empty_statement.to_format_element(formatter) } - JsAnyStatement::ExprStmt(expr_stmt) => expr_stmt.to_format_element(formatter), + JsAnyStatement::JsExpressionStatement(expr_stmt) => { + expr_stmt.to_format_element(formatter) + } JsAnyStatement::IfStmt(if_stmt) => if_stmt.to_format_element(formatter), JsAnyStatement::DoWhileStmt(do_while_statement) => { do_while_statement.to_format_element(formatter) @@ -26,9 +28,11 @@ impl ToFormatElement for JsAnyStatement { JsAnyStatement::BreakStmt(break_statement) => { break_statement.to_format_element(formatter) } - JsAnyStatement::ReturnStmt(stmt) => stmt.to_format_element(formatter), - JsAnyStatement::WithStmt(with_statement) => with_statement.to_format_element(formatter), - JsAnyStatement::LabelledStmt(label_statement) => { + JsAnyStatement::JsReturnStatement(stmt) => stmt.to_format_element(formatter), + JsAnyStatement::JsWithStatement(with_statement) => { + with_statement.to_format_element(formatter) + } + JsAnyStatement::JsLabeledStatement(label_statement) => { label_statement.to_format_element(formatter) } JsAnyStatement::SwitchStmt(switch_statement) => { @@ -38,7 +42,7 @@ impl ToFormatElement for JsAnyStatement { throw_statement.to_format_element(formatter) } JsAnyStatement::TryStmt(try_statement) => try_statement.to_format_element(formatter), - JsAnyStatement::DebuggerStmt(debugger_statement) => { + JsAnyStatement::JsDebuggerStatement(debugger_statement) => { debugger_statement.to_format_element(formatter) } diff --git a/crates/rome_formatter/src/ts/statements/with_statement.rs b/crates/rome_formatter/src/ts/statements/with_statement.rs index 4208f50148e..e283f84127a 100644 --- a/crates/rome_formatter/src/ts/statements/with_statement.rs +++ b/crates/rome_formatter/src/ts/statements/with_statement.rs @@ -1,20 +1,21 @@ use crate::{ - format_elements, space_token, FormatElement, FormatResult, Formatter, ToFormatElement, + format_elements, group_elements, soft_indent, space_token, FormatElement, FormatResult, + Formatter, ToFormatElement, }; -use rslint_parser::ast::WithStmt; +use rslint_parser::ast::JsWithStatement; -impl ToFormatElement for WithStmt { +impl ToFormatElement for JsWithStatement { fn to_format_element(&self, formatter: &Formatter) -> FormatResult { - let with_token = formatter.format_token(&self.with_token()?)?; - let condition = formatter.format_node(self.condition()?)?; - let cons = formatter.format_node(self.cons()?)?; - Ok(format_elements![ - with_token, + formatter.format_token(&self.with_token()?)?, space_token(), - condition, + group_elements(format_elements![ + formatter.format_token(&self.l_paren_token()?)?, + soft_indent(formatter.format_node(self.object()?)?), + formatter.format_token(&self.r_paren_token()?)? + ]), space_token(), - cons + formatter.format_node(self.body()?)? ]) } } diff --git a/crates/rslint_parser/src/ast/generated/nodes.rs b/crates/rslint_parser/src/ast/generated/nodes.rs index 1c435b5d17c..0f8a2b0fc47 100644 --- a/crates/rslint_parser/src/ast/generated/nodes.rs +++ b/crates/rslint_parser/src/ast/generated/nodes.rs @@ -83,33 +83,40 @@ impl JsModule { } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct BlockStmt { +pub struct JsBlockStatement { pub(crate) syntax: SyntaxNode, } -impl BlockStmt { +impl JsBlockStatement { pub fn l_curly_token(&self) -> SyntaxResult { support::as_mandatory_token(&self.syntax, T!['{']) } - pub fn stmts(&self) -> AstNodeList { support::node_list(&self.syntax, 0usize) } + pub fn statements(&self) -> AstNodeList { + support::node_list(&self.syntax, 0usize) + } pub fn r_curly_token(&self) -> SyntaxResult { support::as_mandatory_token(&self.syntax, T!['}']) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct EmptyStmt { +pub struct JsEmptyStatement { pub(crate) syntax: SyntaxNode, } -impl EmptyStmt { - pub fn semicolon_token(&self) -> Option { - support::as_optional_token(&self.syntax, T ! [;]) +impl JsEmptyStatement { + pub fn semicolon_token(&self) -> SyntaxResult { + support::as_mandatory_token(&self.syntax, T ! [;]) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ExprStmt { +pub struct JsExpressionStatement { pub(crate) syntax: SyntaxNode, } -impl ExprStmt { - pub fn expr(&self) -> SyntaxResult { support::as_mandatory_node(&self.syntax) } +impl JsExpressionStatement { + pub fn expression(&self) -> SyntaxResult { + support::as_mandatory_node(&self.syntax) + } + pub fn semicolon_token(&self) -> Option { + support::as_optional_token(&self.syntax, T ! [;]) + } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct IfStmt { @@ -246,41 +253,49 @@ impl BreakStmt { } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ReturnStmt { +pub struct JsReturnStatement { pub(crate) syntax: SyntaxNode, } -impl ReturnStmt { +impl JsReturnStatement { pub fn return_token(&self) -> SyntaxResult { support::as_mandatory_token(&self.syntax, T![return]) } - pub fn value(&self) -> SyntaxResult { - support::as_mandatory_node(&self.syntax) - } + pub fn argument(&self) -> Option { support::as_optional_node(&self.syntax) } pub fn semicolon_token(&self) -> Option { support::as_optional_token(&self.syntax, T ! [;]) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct WithStmt { +pub struct JsWithStatement { pub(crate) syntax: SyntaxNode, } -impl WithStmt { +impl JsWithStatement { pub fn with_token(&self) -> SyntaxResult { support::as_mandatory_token(&self.syntax, T![with]) } - pub fn condition(&self) -> SyntaxResult { support::as_mandatory_node(&self.syntax) } - pub fn cons(&self) -> SyntaxResult { support::as_mandatory_node(&self.syntax) } + pub fn l_paren_token(&self) -> SyntaxResult { + support::as_mandatory_token(&self.syntax, T!['(']) + } + pub fn object(&self) -> SyntaxResult { + support::as_mandatory_node(&self.syntax) + } + pub fn r_paren_token(&self) -> SyntaxResult { + support::as_mandatory_token(&self.syntax, T![')']) + } + pub fn body(&self) -> SyntaxResult { support::as_mandatory_node(&self.syntax) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct LabelledStmt { +pub struct JsLabeledStatement { pub(crate) syntax: SyntaxNode, } -impl LabelledStmt { - pub fn label(&self) -> SyntaxResult { support::as_mandatory_node(&self.syntax) } +impl JsLabeledStatement { + pub fn label_token(&self) -> SyntaxResult { + support::as_mandatory_token(&self.syntax, T![ident]) + } pub fn colon_token(&self) -> SyntaxResult { support::as_mandatory_token(&self.syntax, T ! [:]) } - pub fn stmt(&self) -> SyntaxResult { support::as_mandatory_node(&self.syntax) } + pub fn body(&self) -> SyntaxResult { support::as_mandatory_node(&self.syntax) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct SwitchStmt { @@ -322,15 +337,17 @@ impl TryStmt { pub fn try_token(&self) -> SyntaxResult { support::as_mandatory_token(&self.syntax, T![try]) } - pub fn test(&self) -> SyntaxResult { support::as_mandatory_node(&self.syntax) } + pub fn test(&self) -> SyntaxResult { + support::as_mandatory_node(&self.syntax) + } pub fn handler(&self) -> Option { support::as_optional_node(&self.syntax) } pub fn finalizer(&self) -> Option { support::as_optional_node(&self.syntax) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct DebuggerStmt { +pub struct JsDebuggerStatement { pub(crate) syntax: SyntaxNode, } -impl DebuggerStmt { +impl JsDebuggerStatement { pub fn debugger_token(&self) -> SyntaxResult { support::as_mandatory_token(&self.syntax, T![debugger]) } @@ -579,15 +596,6 @@ impl NameRef { } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Name { - pub(crate) syntax: SyntaxNode, -} -impl Name { - pub fn ident_token(&self) -> SyntaxResult { - support::as_mandatory_token(&self.syntax, T![ident]) - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct CaseClause { pub(crate) syntax: SyntaxNode, } @@ -629,7 +637,9 @@ impl CatchClause { pub fn r_paren_token(&self) -> SyntaxResult { support::as_mandatory_token(&self.syntax, T![')']) } - pub fn cons(&self) -> SyntaxResult { support::as_mandatory_node(&self.syntax) } + pub fn cons(&self) -> SyntaxResult { + support::as_mandatory_node(&self.syntax) + } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct Finalizer { @@ -639,7 +649,9 @@ impl Finalizer { pub fn finally_token(&self) -> SyntaxResult { support::as_mandatory_token(&self.syntax, T![finally]) } - pub fn cons(&self) -> SyntaxResult { support::as_mandatory_node(&self.syntax) } + pub fn cons(&self) -> SyntaxResult { + support::as_mandatory_node(&self.syntax) + } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct ArrowExpr { @@ -957,7 +969,9 @@ impl FnExpr { support::as_optional_token(&self.syntax, T ! [:]) } pub fn return_type(&self) -> Option { support::as_optional_node(&self.syntax) } - pub fn body(&self) -> SyntaxResult { support::as_mandatory_node(&self.syntax) } + pub fn body(&self) -> SyntaxResult { + support::as_mandatory_node(&self.syntax) + } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct ClassExpr { @@ -1112,6 +1126,15 @@ impl TsConstAssertion { } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Name { + pub(crate) syntax: SyntaxNode, +} +impl Name { + pub fn ident_token(&self) -> SyntaxResult { + support::as_mandatory_token(&self.syntax, T![ident]) + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct TsTypeArgs { pub(crate) syntax: SyntaxNode, } @@ -1213,7 +1236,9 @@ impl Method { support::as_optional_token(&self.syntax, T ! [:]) } pub fn return_type(&self) -> Option { support::as_optional_node(&self.syntax) } - pub fn body(&self) -> SyntaxResult { support::as_mandatory_node(&self.syntax) } + pub fn body(&self) -> SyntaxResult { + support::as_mandatory_node(&self.syntax) + } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct PrivateProp { @@ -1271,7 +1296,9 @@ impl Constructor { pub fn parameters(&self) -> SyntaxResult { support::as_mandatory_node(&self.syntax) } - pub fn body(&self) -> SyntaxResult { support::as_mandatory_node(&self.syntax) } + pub fn body(&self) -> SyntaxResult { + support::as_mandatory_node(&self.syntax) + } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct TsIndexSignature { @@ -1305,7 +1332,9 @@ impl Getter { pub fn parameters(&self) -> SyntaxResult { support::as_mandatory_node(&self.syntax) } - pub fn body(&self) -> SyntaxResult { support::as_mandatory_node(&self.syntax) } + pub fn body(&self) -> SyntaxResult { + support::as_mandatory_node(&self.syntax) + } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct Setter { @@ -1319,7 +1348,9 @@ impl Setter { pub fn parameters(&self) -> SyntaxResult { support::as_mandatory_node(&self.syntax) } - pub fn body(&self) -> SyntaxResult { support::as_mandatory_node(&self.syntax) } + pub fn body(&self) -> SyntaxResult { + support::as_mandatory_node(&self.syntax) + } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct TsAccessibility { @@ -1573,7 +1604,9 @@ impl FnDecl { support::as_optional_token(&self.syntax, T ! [:]) } pub fn return_type(&self) -> Option { support::as_optional_node(&self.syntax) } - pub fn body(&self) -> SyntaxResult { support::as_mandatory_node(&self.syntax) } + pub fn body(&self) -> SyntaxResult { + support::as_mandatory_node(&self.syntax) + } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct ClassDecl { @@ -2308,9 +2341,9 @@ impl TsQualifiedPath { } #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub enum JsAnyStatement { - BlockStmt(BlockStmt), - EmptyStmt(EmptyStmt), - ExprStmt(ExprStmt), + JsBlockStatement(JsBlockStatement), + JsEmptyStatement(JsEmptyStatement), + JsExpressionStatement(JsExpressionStatement), IfStmt(IfStmt), DoWhileStmt(DoWhileStmt), WhileStmt(WhileStmt), @@ -2319,13 +2352,13 @@ pub enum JsAnyStatement { ForOfStmt(ForOfStmt), ContinueStmt(ContinueStmt), BreakStmt(BreakStmt), - ReturnStmt(ReturnStmt), - WithStmt(WithStmt), - LabelledStmt(LabelledStmt), + JsReturnStatement(JsReturnStatement), + JsWithStatement(JsWithStatement), + JsLabeledStatement(JsLabeledStatement), SwitchStmt(SwitchStmt), ThrowStmt(ThrowStmt), TryStmt(TryStmt), - DebuggerStmt(DebuggerStmt), + JsDebuggerStatement(JsDebuggerStatement), Decl(Decl), ImportDecl(ImportDecl), ExportNamed(ExportNamed), @@ -2446,7 +2479,7 @@ pub enum ArrowExprParams { #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub enum ExprOrBlock { JsAnyExpression(JsAnyExpression), - BlockStmt(BlockStmt), + JsBlockStatement(JsBlockStatement), } #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub enum ObjectProp { @@ -2461,7 +2494,7 @@ pub enum ObjectProp { } #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub enum ClassElement { - EmptyStmt(EmptyStmt), + JsEmptyStatement(JsEmptyStatement), Method(Method), PrivateProp(PrivateProp), ClassProp(ClassProp), @@ -2642,8 +2675,8 @@ impl AstNode for JsModule { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl AstNode for BlockStmt { - fn can_cast(kind: SyntaxKind) -> bool { kind == BLOCK_STMT } +impl AstNode for JsBlockStatement { + fn can_cast(kind: SyntaxKind) -> bool { kind == JS_BLOCK_STATEMENT } fn cast(syntax: SyntaxNode) -> Option { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2653,8 +2686,8 @@ impl AstNode for BlockStmt { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl AstNode for EmptyStmt { - fn can_cast(kind: SyntaxKind) -> bool { kind == EMPTY_STMT } +impl AstNode for JsEmptyStatement { + fn can_cast(kind: SyntaxKind) -> bool { kind == JS_EMPTY_STATEMENT } fn cast(syntax: SyntaxNode) -> Option { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2664,8 +2697,8 @@ impl AstNode for EmptyStmt { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl AstNode for ExprStmt { - fn can_cast(kind: SyntaxKind) -> bool { kind == EXPR_STMT } +impl AstNode for JsExpressionStatement { + fn can_cast(kind: SyntaxKind) -> bool { kind == JS_EXPRESSION_STATEMENT } fn cast(syntax: SyntaxNode) -> Option { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2763,8 +2796,8 @@ impl AstNode for BreakStmt { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl AstNode for ReturnStmt { - fn can_cast(kind: SyntaxKind) -> bool { kind == RETURN_STMT } +impl AstNode for JsReturnStatement { + fn can_cast(kind: SyntaxKind) -> bool { kind == JS_RETURN_STATEMENT } fn cast(syntax: SyntaxNode) -> Option { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2774,8 +2807,8 @@ impl AstNode for ReturnStmt { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl AstNode for WithStmt { - fn can_cast(kind: SyntaxKind) -> bool { kind == WITH_STMT } +impl AstNode for JsWithStatement { + fn can_cast(kind: SyntaxKind) -> bool { kind == JS_WITH_STATEMENT } fn cast(syntax: SyntaxNode) -> Option { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2785,8 +2818,8 @@ impl AstNode for WithStmt { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl AstNode for LabelledStmt { - fn can_cast(kind: SyntaxKind) -> bool { kind == LABELLED_STMT } +impl AstNode for JsLabeledStatement { + fn can_cast(kind: SyntaxKind) -> bool { kind == JS_LABELED_STATEMENT } fn cast(syntax: SyntaxNode) -> Option { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2829,8 +2862,8 @@ impl AstNode for TryStmt { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl AstNode for DebuggerStmt { - fn can_cast(kind: SyntaxKind) -> bool { kind == DEBUGGER_STMT } +impl AstNode for JsDebuggerStatement { + fn can_cast(kind: SyntaxKind) -> bool { kind == JS_DEBUGGER_STATEMENT } fn cast(syntax: SyntaxNode) -> Option { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3005,17 +3038,6 @@ impl AstNode for NameRef { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl AstNode for Name { - fn can_cast(kind: SyntaxKind) -> bool { kind == NAME } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { &self.syntax } -} impl AstNode for CaseClause { fn can_cast(kind: SyntaxKind) -> bool { kind == CASE_CLAUSE } fn cast(syntax: SyntaxNode) -> Option { @@ -3390,6 +3412,17 @@ impl AstNode for TsConstAssertion { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } +impl AstNode for Name { + fn can_cast(kind: SyntaxKind) -> bool { kind == NAME } + fn cast(syntax: SyntaxNode) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxNode { &self.syntax } +} impl AstNode for TsTypeArgs { fn can_cast(kind: SyntaxKind) -> bool { kind == TS_TYPE_ARGS } fn cast(syntax: SyntaxNode) -> Option { @@ -4402,14 +4435,16 @@ impl AstNode for TsQualifiedPath { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl From for JsAnyStatement { - fn from(node: BlockStmt) -> JsAnyStatement { JsAnyStatement::BlockStmt(node) } +impl From for JsAnyStatement { + fn from(node: JsBlockStatement) -> JsAnyStatement { JsAnyStatement::JsBlockStatement(node) } } -impl From for JsAnyStatement { - fn from(node: EmptyStmt) -> JsAnyStatement { JsAnyStatement::EmptyStmt(node) } +impl From for JsAnyStatement { + fn from(node: JsEmptyStatement) -> JsAnyStatement { JsAnyStatement::JsEmptyStatement(node) } } -impl From for JsAnyStatement { - fn from(node: ExprStmt) -> JsAnyStatement { JsAnyStatement::ExprStmt(node) } +impl From for JsAnyStatement { + fn from(node: JsExpressionStatement) -> JsAnyStatement { + JsAnyStatement::JsExpressionStatement(node) + } } impl From for JsAnyStatement { fn from(node: IfStmt) -> JsAnyStatement { JsAnyStatement::IfStmt(node) } @@ -4435,14 +4470,14 @@ impl From for JsAnyStatement { impl From for JsAnyStatement { fn from(node: BreakStmt) -> JsAnyStatement { JsAnyStatement::BreakStmt(node) } } -impl From for JsAnyStatement { - fn from(node: ReturnStmt) -> JsAnyStatement { JsAnyStatement::ReturnStmt(node) } +impl From for JsAnyStatement { + fn from(node: JsReturnStatement) -> JsAnyStatement { JsAnyStatement::JsReturnStatement(node) } } -impl From for JsAnyStatement { - fn from(node: WithStmt) -> JsAnyStatement { JsAnyStatement::WithStmt(node) } +impl From for JsAnyStatement { + fn from(node: JsWithStatement) -> JsAnyStatement { JsAnyStatement::JsWithStatement(node) } } -impl From for JsAnyStatement { - fn from(node: LabelledStmt) -> JsAnyStatement { JsAnyStatement::LabelledStmt(node) } +impl From for JsAnyStatement { + fn from(node: JsLabeledStatement) -> JsAnyStatement { JsAnyStatement::JsLabeledStatement(node) } } impl From for JsAnyStatement { fn from(node: SwitchStmt) -> JsAnyStatement { JsAnyStatement::SwitchStmt(node) } @@ -4453,8 +4488,10 @@ impl From for JsAnyStatement { impl From for JsAnyStatement { fn from(node: TryStmt) -> JsAnyStatement { JsAnyStatement::TryStmt(node) } } -impl From for JsAnyStatement { - fn from(node: DebuggerStmt) -> JsAnyStatement { JsAnyStatement::DebuggerStmt(node) } +impl From for JsAnyStatement { + fn from(node: JsDebuggerStatement) -> JsAnyStatement { + JsAnyStatement::JsDebuggerStatement(node) + } } impl From for JsAnyStatement { fn from(node: ImportDecl) -> JsAnyStatement { JsAnyStatement::ImportDecl(node) } @@ -4491,9 +4528,9 @@ impl From for JsAnyStatement { impl AstNode for JsAnyStatement { fn can_cast(kind: SyntaxKind) -> bool { match kind { - BLOCK_STMT - | EMPTY_STMT - | EXPR_STMT + JS_BLOCK_STATEMENT + | JS_EMPTY_STATEMENT + | JS_EXPRESSION_STATEMENT | IF_STMT | DO_WHILE_STMT | WHILE_STMT @@ -4502,13 +4539,13 @@ impl AstNode for JsAnyStatement { | FOR_OF_STMT | CONTINUE_STMT | BREAK_STMT - | RETURN_STMT - | WITH_STMT - | LABELLED_STMT + | JS_RETURN_STATEMENT + | JS_WITH_STATEMENT + | JS_LABELED_STATEMENT | SWITCH_STMT | THROW_STMT | TRY_STMT - | DEBUGGER_STMT + | JS_DEBUGGER_STATEMENT | IMPORT_DECL | EXPORT_NAMED | EXPORT_DEFAULT_DECL @@ -4525,9 +4562,11 @@ impl AstNode for JsAnyStatement { } fn cast(syntax: SyntaxNode) -> Option { let res = match syntax.kind() { - BLOCK_STMT => JsAnyStatement::BlockStmt(BlockStmt { syntax }), - EMPTY_STMT => JsAnyStatement::EmptyStmt(EmptyStmt { syntax }), - EXPR_STMT => JsAnyStatement::ExprStmt(ExprStmt { syntax }), + JS_BLOCK_STATEMENT => JsAnyStatement::JsBlockStatement(JsBlockStatement { syntax }), + JS_EMPTY_STATEMENT => JsAnyStatement::JsEmptyStatement(JsEmptyStatement { syntax }), + JS_EXPRESSION_STATEMENT => { + JsAnyStatement::JsExpressionStatement(JsExpressionStatement { syntax }) + } IF_STMT => JsAnyStatement::IfStmt(IfStmt { syntax }), DO_WHILE_STMT => JsAnyStatement::DoWhileStmt(DoWhileStmt { syntax }), WHILE_STMT => JsAnyStatement::WhileStmt(WhileStmt { syntax }), @@ -4536,13 +4575,17 @@ impl AstNode for JsAnyStatement { FOR_OF_STMT => JsAnyStatement::ForOfStmt(ForOfStmt { syntax }), CONTINUE_STMT => JsAnyStatement::ContinueStmt(ContinueStmt { syntax }), BREAK_STMT => JsAnyStatement::BreakStmt(BreakStmt { syntax }), - RETURN_STMT => JsAnyStatement::ReturnStmt(ReturnStmt { syntax }), - WITH_STMT => JsAnyStatement::WithStmt(WithStmt { syntax }), - LABELLED_STMT => JsAnyStatement::LabelledStmt(LabelledStmt { syntax }), + JS_RETURN_STATEMENT => JsAnyStatement::JsReturnStatement(JsReturnStatement { syntax }), + JS_WITH_STATEMENT => JsAnyStatement::JsWithStatement(JsWithStatement { syntax }), + JS_LABELED_STATEMENT => { + JsAnyStatement::JsLabeledStatement(JsLabeledStatement { syntax }) + } SWITCH_STMT => JsAnyStatement::SwitchStmt(SwitchStmt { syntax }), THROW_STMT => JsAnyStatement::ThrowStmt(ThrowStmt { syntax }), TRY_STMT => JsAnyStatement::TryStmt(TryStmt { syntax }), - DEBUGGER_STMT => JsAnyStatement::DebuggerStmt(DebuggerStmt { syntax }), + JS_DEBUGGER_STATEMENT => { + JsAnyStatement::JsDebuggerStatement(JsDebuggerStatement { syntax }) + } IMPORT_DECL => JsAnyStatement::ImportDecl(ImportDecl { syntax }), EXPORT_NAMED => JsAnyStatement::ExportNamed(ExportNamed { syntax }), EXPORT_DEFAULT_DECL => JsAnyStatement::ExportDefaultDecl(ExportDefaultDecl { syntax }), @@ -4572,9 +4615,9 @@ impl AstNode for JsAnyStatement { } fn syntax(&self) -> &SyntaxNode { match self { - JsAnyStatement::BlockStmt(it) => &it.syntax, - JsAnyStatement::EmptyStmt(it) => &it.syntax, - JsAnyStatement::ExprStmt(it) => &it.syntax, + JsAnyStatement::JsBlockStatement(it) => &it.syntax, + JsAnyStatement::JsEmptyStatement(it) => &it.syntax, + JsAnyStatement::JsExpressionStatement(it) => &it.syntax, JsAnyStatement::IfStmt(it) => &it.syntax, JsAnyStatement::DoWhileStmt(it) => &it.syntax, JsAnyStatement::WhileStmt(it) => &it.syntax, @@ -4583,13 +4626,13 @@ impl AstNode for JsAnyStatement { JsAnyStatement::ForOfStmt(it) => &it.syntax, JsAnyStatement::ContinueStmt(it) => &it.syntax, JsAnyStatement::BreakStmt(it) => &it.syntax, - JsAnyStatement::ReturnStmt(it) => &it.syntax, - JsAnyStatement::WithStmt(it) => &it.syntax, - JsAnyStatement::LabelledStmt(it) => &it.syntax, + JsAnyStatement::JsReturnStatement(it) => &it.syntax, + JsAnyStatement::JsWithStatement(it) => &it.syntax, + JsAnyStatement::JsLabeledStatement(it) => &it.syntax, JsAnyStatement::SwitchStmt(it) => &it.syntax, JsAnyStatement::ThrowStmt(it) => &it.syntax, JsAnyStatement::TryStmt(it) => &it.syntax, - JsAnyStatement::DebuggerStmt(it) => &it.syntax, + JsAnyStatement::JsDebuggerStatement(it) => &it.syntax, JsAnyStatement::ImportDecl(it) => &it.syntax, JsAnyStatement::ExportNamed(it) => &it.syntax, JsAnyStatement::ExportDefaultDecl(it) => &it.syntax, @@ -5202,20 +5245,20 @@ impl AstNode for ArrowExprParams { } } } -impl From for ExprOrBlock { - fn from(node: BlockStmt) -> ExprOrBlock { ExprOrBlock::BlockStmt(node) } +impl From for ExprOrBlock { + fn from(node: JsBlockStatement) -> ExprOrBlock { ExprOrBlock::JsBlockStatement(node) } } impl AstNode for ExprOrBlock { fn can_cast(kind: SyntaxKind) -> bool { match kind { - BLOCK_STMT => true, + JS_BLOCK_STATEMENT => true, k if JsAnyExpression::can_cast(k) => true, _ => false, } } fn cast(syntax: SyntaxNode) -> Option { let res = match syntax.kind() { - BLOCK_STMT => ExprOrBlock::BlockStmt(BlockStmt { syntax }), + JS_BLOCK_STATEMENT => ExprOrBlock::JsBlockStatement(JsBlockStatement { syntax }), _ => { if let Some(js_any_expression) = JsAnyExpression::cast(syntax) { return Some(ExprOrBlock::JsAnyExpression(js_any_expression)); @@ -5227,7 +5270,7 @@ impl AstNode for ExprOrBlock { } fn syntax(&self) -> &SyntaxNode { match self { - ExprOrBlock::BlockStmt(it) => &it.syntax, + ExprOrBlock::JsBlockStatement(it) => &it.syntax, ExprOrBlock::JsAnyExpression(it) => it.syntax(), } } @@ -5291,8 +5334,8 @@ impl AstNode for ObjectProp { } } } -impl From for ClassElement { - fn from(node: EmptyStmt) -> ClassElement { ClassElement::EmptyStmt(node) } +impl From for ClassElement { + fn from(node: JsEmptyStatement) -> ClassElement { ClassElement::JsEmptyStatement(node) } } impl From for ClassElement { fn from(node: Method) -> ClassElement { ClassElement::Method(node) } @@ -5321,14 +5364,14 @@ impl From for ClassElement { impl AstNode for ClassElement { fn can_cast(kind: SyntaxKind) -> bool { match kind { - EMPTY_STMT | METHOD | PRIVATE_PROP | CLASS_PROP | CONSTRUCTOR | TS_INDEX_SIGNATURE - | GETTER | SETTER | JS_UNKNOWN_MEMBER => true, + JS_EMPTY_STATEMENT | METHOD | PRIVATE_PROP | CLASS_PROP | CONSTRUCTOR + | TS_INDEX_SIGNATURE | GETTER | SETTER | JS_UNKNOWN_MEMBER => true, _ => false, } } fn cast(syntax: SyntaxNode) -> Option { let res = match syntax.kind() { - EMPTY_STMT => ClassElement::EmptyStmt(EmptyStmt { syntax }), + JS_EMPTY_STATEMENT => ClassElement::JsEmptyStatement(JsEmptyStatement { syntax }), METHOD => ClassElement::Method(Method { syntax }), PRIVATE_PROP => ClassElement::PrivateProp(PrivateProp { syntax }), CLASS_PROP => ClassElement::ClassProp(ClassProp { syntax }), @@ -5343,7 +5386,7 @@ impl AstNode for ClassElement { } fn syntax(&self) -> &SyntaxNode { match self { - ClassElement::EmptyStmt(it) => &it.syntax, + ClassElement::JsEmptyStatement(it) => &it.syntax, ClassElement::Method(it) => &it.syntax, ClassElement::PrivateProp(it) => &it.syntax, ClassElement::ClassProp(it) => &it.syntax, @@ -5940,17 +5983,17 @@ impl std::fmt::Display for JsModule { std::fmt::Display::fmt(self.syntax(), f) } } -impl std::fmt::Display for BlockStmt { +impl std::fmt::Display for JsBlockStatement { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { std::fmt::Display::fmt(self.syntax(), f) } } -impl std::fmt::Display for EmptyStmt { +impl std::fmt::Display for JsEmptyStatement { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { std::fmt::Display::fmt(self.syntax(), f) } } -impl std::fmt::Display for ExprStmt { +impl std::fmt::Display for JsExpressionStatement { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { std::fmt::Display::fmt(self.syntax(), f) } @@ -5995,17 +6038,17 @@ impl std::fmt::Display for BreakStmt { std::fmt::Display::fmt(self.syntax(), f) } } -impl std::fmt::Display for ReturnStmt { +impl std::fmt::Display for JsReturnStatement { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { std::fmt::Display::fmt(self.syntax(), f) } } -impl std::fmt::Display for WithStmt { +impl std::fmt::Display for JsWithStatement { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { std::fmt::Display::fmt(self.syntax(), f) } } -impl std::fmt::Display for LabelledStmt { +impl std::fmt::Display for JsLabeledStatement { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { std::fmt::Display::fmt(self.syntax(), f) } @@ -6025,7 +6068,7 @@ impl std::fmt::Display for TryStmt { std::fmt::Display::fmt(self.syntax(), f) } } -impl std::fmt::Display for DebuggerStmt { +impl std::fmt::Display for JsDebuggerStatement { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { std::fmt::Display::fmt(self.syntax(), f) } @@ -6105,11 +6148,6 @@ impl std::fmt::Display for NameRef { std::fmt::Display::fmt(self.syntax(), f) } } -impl std::fmt::Display for Name { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} impl std::fmt::Display for CaseClause { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { std::fmt::Display::fmt(self.syntax(), f) @@ -6280,6 +6318,11 @@ impl std::fmt::Display for TsConstAssertion { std::fmt::Display::fmt(self.syntax(), f) } } +impl std::fmt::Display for Name { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + std::fmt::Display::fmt(self.syntax(), f) + } +} impl std::fmt::Display for TsTypeArgs { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { std::fmt::Display::fmt(self.syntax(), f) diff --git a/crates/rslint_parser/src/syntax/decl.rs b/crates/rslint_parser/src/syntax/decl.rs index 3054da84d22..7f3202b4a8a 100644 --- a/crates/rslint_parser/src/syntax/decl.rs +++ b/crates/rslint_parser/src/syntax/decl.rs @@ -600,7 +600,7 @@ pub(crate) fn class_body(p: &mut Parser) -> CompletedMarker { T![;] => { let inner = p.start(); p.bump_any(); - inner.complete(p, EMPTY_STMT); + inner.complete(p, JS_EMPTY_STATEMENT); } // test static_method // class foo { diff --git a/crates/rslint_parser/src/syntax/program.rs b/crates/rslint_parser/src/syntax/program.rs index bd447c0e51f..a1483870e1c 100644 --- a/crates/rslint_parser/src/syntax/program.rs +++ b/crates/rslint_parser/src/syntax/program.rs @@ -91,7 +91,7 @@ pub fn import_decl(p: &mut Parser) -> CompletedMarker { the current token is guaranteed to be `IMPORT_KW`", ); semi(p, start..p.cur_tok().range.start); - return m.complete(p, EXPR_STMT); + return m.complete(p, JS_EXPRESSION_STATEMENT); } let p = &mut *p.with_state(ParserState { diff --git a/crates/rslint_parser/src/syntax/stmt.rs b/crates/rslint_parser/src/syntax/stmt.rs index 064012b53a9..08e019d0043 100644 --- a/crates/rslint_parser/src/syntax/stmt.rs +++ b/crates/rslint_parser/src/syntax/stmt.rs @@ -266,15 +266,15 @@ fn expr_stmt(p: &mut Parser, decorator: Option) -> Option CompletedMarker { let range = p.cur_tok().range; p.expect(T![debugger]); semi(p, range); - m.complete(p, DEBUGGER_STMT) + m.complete(p, JS_DEBUGGER_STATEMENT) } /// A throw statement such as `throw new Error("uh oh");` @@ -408,7 +408,7 @@ pub fn return_stmt(p: &mut Parser) -> CompletedMarker { p.expr_with_semi_recovery(false); } semi(p, start..p.cur_tok().range.end); - let complete = m.complete(p, RETURN_STMT); + let complete = m.complete(p, JS_RETURN_STATEMENT); if !p.state.in_function && !p.syntax.global_return { let err = p @@ -426,7 +426,7 @@ pub fn return_stmt(p: &mut Parser) -> CompletedMarker { pub fn empty_stmt(p: &mut Parser) -> CompletedMarker { let m = p.start(); p.expect(T![;]); - m.complete(p, EMPTY_STMT) + m.complete(p, JS_EMPTY_STATEMENT) } /// A block statement consisting of statements wrapped in curly brackets. @@ -458,7 +458,7 @@ pub fn block_stmt( guard.bump(T!['{']); block_items(&mut *guard, function_body, false, true, recovery_set); guard.expect(T!['}']); - Some(m.complete(&mut *guard, BLOCK_STMT)) + Some(m.complete(&mut *guard, JS_BLOCK_STATEMENT)) } pub fn block_stmt_unchecked(p: &mut Parser, function_body: bool) -> CompletedMarker { @@ -466,7 +466,7 @@ pub fn block_stmt_unchecked(p: &mut Parser, function_body: bool) -> CompletedMar p.bump(T!['{']); block_items(p, function_body, false, true, None); p.expect(T!['}']); - m.complete(p, BLOCK_STMT) + m.complete(p, JS_BLOCK_STATEMENT) } /// Top level items or items inside of a block statement, this also handles module items so we can @@ -586,10 +586,10 @@ pub(crate) fn block_items( // Still makes the function body strict if let Some(kind) = complete.map(|x| x.kind()).filter(|_| could_be_directive) { match kind { - EXPR_STMT => { + JS_EXPRESSION_STATEMENT => { let parsed = p - .parse_marker::(complete.as_ref().unwrap()) - .expr(); + .parse_marker::(complete.as_ref().unwrap()) + .expression(); if let Ok(LITERAL) = parsed.as_ref().map(|it| it.syntax().kind()) { let unwrapped = parsed.unwrap().syntax().to::(); if unwrapped.is_string() { @@ -656,10 +656,14 @@ pub fn if_stmt(p: &mut Parser) -> CompletedMarker { pub fn with_stmt(p: &mut Parser) -> CompletedMarker { let m = p.start(); p.expect(T![with]); - condition(p); + + p.expect(T!['(']); + expr(p); + p.expect(T![')']); + stmt(p, None, None); - let mut complete = m.complete(p, WITH_STMT); + let mut complete = m.complete(p, JS_WITH_STATEMENT); if p.state.strict.is_some() { let err = p .err_builder("`with` statements are not allowed in strict mode") diff --git a/crates/rslint_parser/src/tests.rs b/crates/rslint_parser/src/tests.rs index a2a7f8169f1..fae0982ca58 100644 --- a/crates/rslint_parser/src/tests.rs +++ b/crates/rslint_parser/src/tests.rs @@ -1,5 +1,5 @@ use crate::ast::ArgList; -use crate::{ast::JsModule, parse_module, AstNode, Parse, ParserError}; +use crate::{parse_module, parse_text, AstNode, ParserError, SyntaxNode}; use expect_test::expect_file; use rslint_errors::{file::SimpleFiles, Emitter}; use rslint_syntax::SyntaxKind; @@ -43,8 +43,29 @@ fn test_data_dir() -> PathBuf { project_dir().join("rslint_parser/test_data") } -fn try_parse(path: &str, text: &str) -> Parse { - let res = catch_unwind(|| parse_module(text, 0)); +struct ParseResult { + root: SyntaxNode, + errors: Vec, +} + +fn try_parse(path: &str, text: &str) -> ParseResult { + let res = catch_unwind(|| { + // Files containing a // SCRIPT comment are parsed as script and not as module + // This is needed to test features that are restricted in strict mode. + if text.contains("// SCRIPT") { + let script = parse_text(text, 0); + ParseResult { + root: script.syntax(), + errors: Vec::from(script.errors()), + } + } else { + let module = parse_module(text, 0); + ParseResult { + root: module.syntax(), + errors: Vec::from(module.errors()), + } + } + }); assert!( !res.is_err(), "Trying to parse `{}` caused infinite recursion", @@ -57,22 +78,23 @@ fn try_parse(path: &str, text: &str) -> Parse { fn parser_tests() { dir_tests(&test_data_dir(), &["inline/ok"], "rast", |text, path| { let parse = try_parse(path.to_str().unwrap(), text); - let errors = parse.errors(); + let errors = parse.errors.as_slice(); assert_errors_are_absent(errors, path); - format!("{:#?}", parse.syntax()) + format!("{:#?}", parse.root) }); + dir_tests(&test_data_dir(), &["inline/err"], "rast", |text, path| { let parse = try_parse(path.to_str().unwrap(), text); - let errors = parse.errors(); + let errors = parse.errors.as_slice(); assert_errors_are_present(errors, path); let mut files = SimpleFiles::new(); files.add( path.file_name().unwrap().to_string_lossy().to_string(), text.to_string(), ); - let mut ret = format!("{:#?}", parse.syntax()); + let mut ret = format!("{:#?}", parse.root); - for diag in parse.errors() { + for diag in &parse.errors { let mut write = rslint_errors::termcolor::Buffer::no_color(); let mut emitter = Emitter::new(&files); emitter @@ -144,7 +166,8 @@ fn assert_errors_are_present(errors: &[ParserError], path: &Path) { fn assert_errors_are_absent(errors: &[ParserError], path: &Path) { assert!( errors.is_empty(), - "There should be no errors in the file {:?}", + "There should be no errors in the file {:?} but the following errors were present: {:?}", path.display(), + errors ); } diff --git a/crates/rslint_parser/test_data/inline/err/async_arrow_expr_await_parameter.rast b/crates/rslint_parser/test_data/inline/err/async_arrow_expr_await_parameter.rast index 718fe084122..188518f3d45 100644 --- a/crates/rslint_parser/test_data/inline/err/async_arrow_expr_await_parameter.rast +++ b/crates/rslint_parser/test_data/inline/err/async_arrow_expr_await_parameter.rast @@ -14,14 +14,14 @@ JS_MODULE@0..26 NAME_REF@8..13 IDENT@8..13 "async" WHITESPACE@13..14 " " - EXPR_STMT@14..25 + JS_EXPRESSION_STATEMENT@14..25 ARROW_EXPR@14..25 NAME@14..19 IDENT@14..19 "await" WHITESPACE@19..20 " " FAT_ARROW@20..22 "=>" WHITESPACE@22..23 " " - BLOCK_STMT@23..25 + JS_BLOCK_STATEMENT@23..25 L_CURLY@23..24 "{" LIST@24..24 R_CURLY@24..25 "}" diff --git a/crates/rslint_parser/test_data/inline/err/binary_expressions_err.rast b/crates/rslint_parser/test_data/inline/err/binary_expressions_err.rast index 475fd5d72c7..9f3bbd5ed65 100644 --- a/crates/rslint_parser/test_data/inline/err/binary_expressions_err.rast +++ b/crates/rslint_parser/test_data/inline/err/binary_expressions_err.rast @@ -1,6 +1,6 @@ JS_MODULE@0..35 LIST@0..34 - EXPR_STMT@0..11 + JS_EXPRESSION_STATEMENT@0..11 CALL_EXPR@0..10 NAME_REF@0..3 IDENT@0..3 "foo" @@ -15,7 +15,7 @@ JS_MODULE@0..35 R_PAREN@9..10 ")" SEMICOLON@10..11 ";" WHITESPACE@11..12 "\n" - EXPR_STMT@12..22 + JS_EXPRESSION_STATEMENT@12..22 BIN_EXPR@12..21 NAME_REF@12..15 IDENT@12..15 "foo" @@ -29,7 +29,7 @@ JS_MODULE@0..35 NUMBER@20..21 "2" SEMICOLON@21..22 ";" WHITESPACE@22..23 "\n" - EXPR_STMT@23..34 + JS_EXPRESSION_STATEMENT@23..34 BIN_EXPR@23..33 UNARY_EXPR@23..27 BANG@23..24 "!" diff --git a/crates/rslint_parser/test_data/inline/err/binding_identifier_invalid.rast b/crates/rslint_parser/test_data/inline/err/binding_identifier_invalid.rast index f37f5a1f8f7..368b21a4e2e 100644 --- a/crates/rslint_parser/test_data/inline/err/binding_identifier_invalid.rast +++ b/crates/rslint_parser/test_data/inline/err/binding_identifier_invalid.rast @@ -1,6 +1,6 @@ JS_MODULE@0..83 LIST@0..82 - EXPR_STMT@0..30 + JS_EXPRESSION_STATEMENT@0..30 ARROW_EXPR@0..30 ASYNC_KW@0..5 "async" WHITESPACE@5..6 " " @@ -11,7 +11,7 @@ JS_MODULE@0..83 WHITESPACE@8..9 " " FAT_ARROW@9..11 "=>" WHITESPACE@11..12 " " - BLOCK_STMT@12..30 + JS_BLOCK_STATEMENT@12..30 L_CURLY@12..13 "{" WHITESPACE@13..14 " " LIST@14..28 @@ -43,7 +43,7 @@ JS_MODULE@0..83 LIST@45..45 R_PAREN@45..46 ")" WHITESPACE@46..47 " " - BLOCK_STMT@47..68 + JS_BLOCK_STATEMENT@47..68 L_CURLY@47..48 "{" WHITESPACE@48..52 "\n " LIST@52..66 diff --git a/crates/rslint_parser/test_data/inline/err/bracket_expr_err.rast b/crates/rslint_parser/test_data/inline/err/bracket_expr_err.rast index 22bfc660b48..e2a806b09e6 100644 --- a/crates/rslint_parser/test_data/inline/err/bracket_expr_err.rast +++ b/crates/rslint_parser/test_data/inline/err/bracket_expr_err.rast @@ -1,13 +1,13 @@ JS_MODULE@0..19 LIST@0..19 - EXPR_STMT@0..5 + JS_EXPRESSION_STATEMENT@0..5 BRACKET_EXPR@0..5 NAME_REF@0..3 IDENT@0..3 "foo" L_BRACK@3..4 "[" R_BRACK@4..5 "]" WHITESPACE@5..6 "\n" - EXPR_STMT@6..13 + JS_EXPRESSION_STATEMENT@6..13 BRACKET_EXPR@6..13 NAME_REF@6..9 IDENT@6..9 "foo" @@ -15,7 +15,7 @@ JS_MODULE@0..19 L_BRACK@11..12 "[" R_BRACK@12..13 "]" WHITESPACE@13..14 "\n" - EXPR_STMT@14..19 + JS_EXPRESSION_STATEMENT@14..19 BRACKET_EXPR@14..19 NAME_REF@14..17 IDENT@14..17 "foo" diff --git a/crates/rslint_parser/test_data/inline/err/conditional_expr_err.rast b/crates/rslint_parser/test_data/inline/err/conditional_expr_err.rast index 99467f2a9bb..c7fd77daad2 100644 --- a/crates/rslint_parser/test_data/inline/err/conditional_expr_err.rast +++ b/crates/rslint_parser/test_data/inline/err/conditional_expr_err.rast @@ -1,6 +1,6 @@ JS_MODULE@0..40 LIST@0..39 - EXPR_STMT@0..13 + JS_EXPRESSION_STATEMENT@0..13 COND_EXPR@0..13 NAME_REF@0..3 IDENT@0..3 "foo" @@ -13,7 +13,7 @@ JS_MODULE@0..40 NAME_REF@10..13 IDENT@10..13 "baz" WHITESPACE@13..14 "\n" - EXPR_STMT@14..39 + JS_EXPRESSION_STATEMENT@14..39 COND_EXPR@14..39 NAME_REF@14..17 IDENT@14..17 "foo" diff --git a/crates/rslint_parser/test_data/inline/err/export_decl_not_top_level.rast b/crates/rslint_parser/test_data/inline/err/export_decl_not_top_level.rast index fc938e98fd4..509ce91c9e9 100644 --- a/crates/rslint_parser/test_data/inline/err/export_decl_not_top_level.rast +++ b/crates/rslint_parser/test_data/inline/err/export_decl_not_top_level.rast @@ -1,6 +1,6 @@ JS_MODULE@0..34 LIST@0..33 - BLOCK_STMT@0..33 + JS_BLOCK_STATEMENT@0..33 L_CURLY@0..1 "{" WHITESPACE@1..3 "\n " LIST@3..31 diff --git a/crates/rslint_parser/test_data/inline/err/for_stmt_err.rast b/crates/rslint_parser/test_data/inline/err/for_stmt_err.rast index 5ca2b1e65e6..d22393f6d35 100644 --- a/crates/rslint_parser/test_data/inline/err/for_stmt_err.rast +++ b/crates/rslint_parser/test_data/inline/err/for_stmt_err.rast @@ -48,7 +48,7 @@ JS_MODULE@0..40 NAME_REF@35..36 IDENT@35..36 "i" WHITESPACE@36..37 " " - BLOCK_STMT@37..39 + JS_BLOCK_STATEMENT@37..39 L_CURLY@37..38 "{" LIST@38..38 R_CURLY@38..39 "}" diff --git a/crates/rslint_parser/test_data/inline/err/formal_params_no_binding_element.rast b/crates/rslint_parser/test_data/inline/err/formal_params_no_binding_element.rast index 9b07bd7efd7..21289467ad7 100644 --- a/crates/rslint_parser/test_data/inline/err/formal_params_no_binding_element.rast +++ b/crates/rslint_parser/test_data/inline/err/formal_params_no_binding_element.rast @@ -12,7 +12,7 @@ JS_MODULE@0..22 TRUE_KW@13..17 "true" R_PAREN@17..18 ")" WHITESPACE@18..19 " " - BLOCK_STMT@19..21 + JS_BLOCK_STATEMENT@19..21 L_CURLY@19..20 "{" LIST@20..20 R_CURLY@20..21 "}" diff --git a/crates/rslint_parser/test_data/inline/err/function_decl_err.rast b/crates/rslint_parser/test_data/inline/err/function_decl_err.rast index 6346a1ec9ee..b9147ba5b3b 100644 --- a/crates/rslint_parser/test_data/inline/err/function_decl_err.rast +++ b/crates/rslint_parser/test_data/inline/err/function_decl_err.rast @@ -7,7 +7,7 @@ JS_MODULE@0..114 LIST@9..9 R_PAREN@9..10 ")" WHITESPACE@10..11 " " - BLOCK_STMT@11..13 + JS_BLOCK_STATEMENT@11..13 L_CURLY@11..12 "{" LIST@12..12 R_CURLY@12..13 "}" @@ -31,7 +31,7 @@ JS_MODULE@0..114 L_PAREN@36..37 "(" R_PAREN@37..38 ")" WHITESPACE@38..39 " " - BLOCK_STMT@39..41 + JS_BLOCK_STATEMENT@39..41 L_CURLY@39..40 "{" LIST@40..40 R_CURLY@40..41 "}" @@ -45,7 +45,7 @@ JS_MODULE@0..114 LIST@57..57 R_PAREN@57..58 ")" WHITESPACE@58..59 " " - BLOCK_STMT@59..61 + JS_BLOCK_STATEMENT@59..61 L_CURLY@59..60 "{" LIST@60..60 R_CURLY@60..61 "}" @@ -61,7 +61,7 @@ JS_MODULE@0..114 LIST@79..79 R_PAREN@79..80 ")" WHITESPACE@80..81 " " - BLOCK_STMT@81..83 + JS_BLOCK_STATEMENT@81..83 L_CURLY@81..82 "{" LIST@82..82 R_CURLY@82..83 "}" @@ -77,16 +77,16 @@ JS_MODULE@0..114 LIST@98..98 R_PAREN@98..99 ")" WHITESPACE@99..100 " " - BLOCK_STMT@100..102 + JS_BLOCK_STATEMENT@100..102 L_CURLY@100..101 "{" LIST@101..101 R_CURLY@101..102 "}" WHITESPACE@102..103 "\n" - EXPR_STMT@103..108 + JS_EXPRESSION_STATEMENT@103..108 NAME_REF@103..108 IDENT@103..108 "yield" WHITESPACE@108..109 " " - EXPR_STMT@109..113 + JS_EXPRESSION_STATEMENT@109..113 NAME_REF@109..112 IDENT@109..112 "foo" SEMICOLON@112..113 ";" diff --git a/crates/rslint_parser/test_data/inline/err/if_stmt_err.rast b/crates/rslint_parser/test_data/inline/err/if_stmt_err.rast index 6d4185a02c6..574fbabe03e 100644 --- a/crates/rslint_parser/test_data/inline/err/if_stmt_err.rast +++ b/crates/rslint_parser/test_data/inline/err/if_stmt_err.rast @@ -11,7 +11,7 @@ JS_MODULE@0..61 WHITESPACE@9..10 " " ELSE_KW@10..14 "else" WHITESPACE@14..15 " " - BLOCK_STMT@15..17 + JS_BLOCK_STATEMENT@15..17 L_CURLY@15..16 "{" LIST@16..16 R_CURLY@16..17 "}" @@ -33,7 +33,7 @@ JS_MODULE@0..61 CONDITION@36..36 ELSE_KW@36..40 "else" WHITESPACE@40..41 " " - BLOCK_STMT@41..43 + JS_BLOCK_STATEMENT@41..43 L_CURLY@41..42 "{" LIST@42..42 R_CURLY@42..43 "}" @@ -45,14 +45,14 @@ JS_MODULE@0..61 L_PAREN@47..48 "(" R_PAREN@48..49 ")" WHITESPACE@49..50 " " - BLOCK_STMT@50..52 + JS_BLOCK_STATEMENT@50..52 L_CURLY@50..51 "{" LIST@51..51 R_CURLY@51..52 "}" WHITESPACE@52..53 " " ELSE_KW@53..57 "else" WHITESPACE@57..58 " " - BLOCK_STMT@58..60 + JS_BLOCK_STATEMENT@58..60 L_CURLY@58..59 "{" LIST@59..59 R_CURLY@59..60 "}" diff --git a/crates/rslint_parser/test_data/inline/err/import_call_no_arg.rast b/crates/rslint_parser/test_data/inline/err/import_call_no_arg.rast index 1a17763f3fb..244e3fff044 100644 --- a/crates/rslint_parser/test_data/inline/err/import_call_no_arg.rast +++ b/crates/rslint_parser/test_data/inline/err/import_call_no_arg.rast @@ -17,7 +17,7 @@ JS_MODULE@0..25 R_PAREN@15..16 ")" SEMICOLON@16..17 ";" WHITESPACE@17..18 "\n" - EXPR_STMT@18..24 + JS_EXPRESSION_STATEMENT@18..24 CALL_EXPR@18..23 NAME_REF@18..21 IDENT@18..21 "foo" diff --git a/crates/rslint_parser/test_data/inline/err/import_decl_not_top_level.rast b/crates/rslint_parser/test_data/inline/err/import_decl_not_top_level.rast index b382f1e6b4c..64b19371fb4 100644 --- a/crates/rslint_parser/test_data/inline/err/import_decl_not_top_level.rast +++ b/crates/rslint_parser/test_data/inline/err/import_decl_not_top_level.rast @@ -1,6 +1,6 @@ JS_MODULE@0..28 LIST@0..27 - BLOCK_STMT@0..27 + JS_BLOCK_STATEMENT@0..27 L_CURLY@0..1 "{" WHITESPACE@1..3 "\n " LIST@3..25 diff --git a/crates/rslint_parser/test_data/inline/err/import_no_meta.rast b/crates/rslint_parser/test_data/inline/err/import_no_meta.rast index d98a9ff8491..23cb5ececac 100644 --- a/crates/rslint_parser/test_data/inline/err/import_no_meta.rast +++ b/crates/rslint_parser/test_data/inline/err/import_no_meta.rast @@ -1,13 +1,13 @@ JS_MODULE@0..24 LIST@0..23 - EXPR_STMT@0..10 + JS_EXPRESSION_STATEMENT@0..10 ERROR@0..10 IMPORT_KW@0..6 "import" DOT@6..7 "." ERROR@7..10 IDENT@7..10 "foo" WHITESPACE@10..11 "\n" - EXPR_STMT@11..23 + JS_EXPRESSION_STATEMENT@11..23 ERROR@11..23 IMPORT_KW@11..17 "import" DOT@17..18 "." diff --git a/crates/rslint_parser/test_data/inline/err/invalid_arg_list.rast b/crates/rslint_parser/test_data/inline/err/invalid_arg_list.rast index 9c168acbcbd..d2dcd11c18a 100644 --- a/crates/rslint_parser/test_data/inline/err/invalid_arg_list.rast +++ b/crates/rslint_parser/test_data/inline/err/invalid_arg_list.rast @@ -1,6 +1,6 @@ JS_MODULE@0..21 LIST@0..21 - EXPR_STMT@0..8 + JS_EXPRESSION_STATEMENT@0..8 CALL_EXPR@0..7 NAME_REF@0..3 IDENT@0..3 "foo" @@ -14,7 +14,7 @@ JS_MODULE@0..21 IDENT@6..7 "b" SEMICOLON@7..8 ";" WHITESPACE@8..9 "\n" - EXPR_STMT@9..16 + JS_EXPRESSION_STATEMENT@9..16 CALL_EXPR@9..16 NAME_REF@9..12 IDENT@9..12 "foo" diff --git a/crates/rslint_parser/test_data/inline/err/invalid_method_recover.rast b/crates/rslint_parser/test_data/inline/err/invalid_method_recover.rast index fee9c8c0126..71c50706280 100644 --- a/crates/rslint_parser/test_data/inline/err/invalid_method_recover.rast +++ b/crates/rslint_parser/test_data/inline/err/invalid_method_recover.rast @@ -30,7 +30,7 @@ JS_MODULE@0..48 WHITESPACE@22..23 " " FAT_ARROW@23..25 "=>" WHITESPACE@25..26 " " - BLOCK_STMT@26..43 + JS_BLOCK_STATEMENT@26..43 L_CURLY@26..27 "{" WHITESPACE@27..32 "\n " LIST@32..39 @@ -50,7 +50,7 @@ JS_MODULE@0..48 SEMICOLON@43..44 ";" WHITESPACE@44..45 "\n" R_CURLY@45..46 "}" - EMPTY_STMT@46..47 + JS_EMPTY_STATEMENT@46..47 SEMICOLON@46..47 ";" WHITESPACE@47..48 "\n" -- diff --git a/crates/rslint_parser/test_data/inline/err/paren_or_arrow_expr_invalid_params.rast b/crates/rslint_parser/test_data/inline/err/paren_or_arrow_expr_invalid_params.rast index 158c649c157..f7676f0f83c 100644 --- a/crates/rslint_parser/test_data/inline/err/paren_or_arrow_expr_invalid_params.rast +++ b/crates/rslint_parser/test_data/inline/err/paren_or_arrow_expr_invalid_params.rast @@ -1,6 +1,6 @@ JS_MODULE@0..14 LIST@0..13 - EXPR_STMT@0..6 + JS_EXPRESSION_STATEMENT@0..6 ARROW_EXPR@0..6 PARAMETER_LIST@0..4 L_PAREN@0..1 "(" @@ -18,7 +18,7 @@ JS_MODULE@0..14 ERROR@8..10 FAT_ARROW@8..10 "=>" WHITESPACE@10..11 " " - BLOCK_STMT@11..13 + JS_BLOCK_STATEMENT@11..13 L_CURLY@11..12 "{" LIST@12..12 R_CURLY@12..13 "}" diff --git a/crates/rslint_parser/test_data/inline/err/primary_expr_invalid_recovery.rast b/crates/rslint_parser/test_data/inline/err/primary_expr_invalid_recovery.rast index e12c995c2da..706933fe718 100644 --- a/crates/rslint_parser/test_data/inline/err/primary_expr_invalid_recovery.rast +++ b/crates/rslint_parser/test_data/inline/err/primary_expr_invalid_recovery.rast @@ -15,7 +15,7 @@ JS_MODULE@0..18 ERROR_TOKEN@8..9 "\\" SEMICOLON@9..10 ";" WHITESPACE@10..11 " " - EXPR_STMT@11..17 + JS_EXPRESSION_STATEMENT@11..17 CALL_EXPR@11..16 NAME_REF@11..14 IDENT@11..14 "foo" diff --git a/crates/rslint_parser/test_data/inline/err/return_stmt_err.rast b/crates/rslint_parser/test_data/inline/err/return_stmt_err.rast index 1fc626d15af..f43ea5d6657 100644 --- a/crates/rslint_parser/test_data/inline/err/return_stmt_err.rast +++ b/crates/rslint_parser/test_data/inline/err/return_stmt_err.rast @@ -1,10 +1,10 @@ JS_MODULE@0..20 LIST@0..19 - RETURN_STMT@0..7 + JS_RETURN_STATEMENT@0..7 RETURN_KW@0..6 "return" SEMICOLON@6..7 ";" WHITESPACE@7..8 "\n" - RETURN_STMT@8..19 + JS_RETURN_STATEMENT@8..19 RETURN_KW@8..14 "return" WHITESPACE@14..15 " " NAME_REF@15..18 diff --git a/crates/rslint_parser/test_data/inline/err/subscripts_err.rast b/crates/rslint_parser/test_data/inline/err/subscripts_err.rast index 4876b12ccae..5e463236a21 100644 --- a/crates/rslint_parser/test_data/inline/err/subscripts_err.rast +++ b/crates/rslint_parser/test_data/inline/err/subscripts_err.rast @@ -1,6 +1,6 @@ JS_MODULE@0..20 LIST@0..20 - EXPR_STMT@0..20 + JS_EXPRESSION_STATEMENT@0..20 TEMPLATE@0..20 DOT_EXPR@0..17 BRACKET_EXPR@0..12 diff --git a/crates/rslint_parser/test_data/inline/err/throw_stmt_err.rast b/crates/rslint_parser/test_data/inline/err/throw_stmt_err.rast index 3f74eb35627..5a736b86861 100644 --- a/crates/rslint_parser/test_data/inline/err/throw_stmt_err.rast +++ b/crates/rslint_parser/test_data/inline/err/throw_stmt_err.rast @@ -3,7 +3,7 @@ JS_MODULE@0..28 THROW_STMT@0..5 THROW_KW@0..5 "throw" WHITESPACE@5..6 "\n" - EXPR_STMT@6..27 + JS_EXPRESSION_STATEMENT@6..27 NEW_EXPR@6..27 NEW_KW@6..9 "new" WHITESPACE@9..10 " " diff --git a/crates/rslint_parser/test_data/inline/err/while_stmt_err.rast b/crates/rslint_parser/test_data/inline/err/while_stmt_err.rast index 68a8620cf37..557640495a5 100644 --- a/crates/rslint_parser/test_data/inline/err/while_stmt_err.rast +++ b/crates/rslint_parser/test_data/inline/err/while_stmt_err.rast @@ -7,7 +7,7 @@ JS_MODULE@0..52 LITERAL@6..10 TRUE_KW@6..10 "true" WHITESPACE@10..11 " " - BLOCK_STMT@11..13 + JS_BLOCK_STATEMENT@11..13 L_CURLY@11..12 "{" LIST@12..12 R_CURLY@12..13 "}" @@ -16,7 +16,7 @@ JS_MODULE@0..52 WHILE_KW@14..19 "while" WHITESPACE@19..20 " " CONDITION@20..20 - BLOCK_STMT@20..22 + JS_BLOCK_STATEMENT@20..22 L_CURLY@20..21 "{" LIST@21..21 R_CURLY@21..22 "}" @@ -29,7 +29,7 @@ JS_MODULE@0..52 LITERAL@30..34 TRUE_KW@30..34 "true" WHITESPACE@34..35 " " - BLOCK_STMT@35..37 + JS_BLOCK_STATEMENT@35..37 L_CURLY@35..36 "{" LIST@36..36 R_CURLY@36..37 "}" diff --git a/crates/rslint_parser/test_data/inline/ok/array_expr.rast b/crates/rslint_parser/test_data/inline/ok/array_expr.rast index 1d503ac32ac..69ba08d4fe1 100644 --- a/crates/rslint_parser/test_data/inline/ok/array_expr.rast +++ b/crates/rslint_parser/test_data/inline/ok/array_expr.rast @@ -1,6 +1,6 @@ JS_MODULE@0..65 LIST@0..64 - EXPR_STMT@0..11 + JS_EXPRESSION_STATEMENT@0..11 ARRAY_EXPR@0..10 L_BRACK@0..1 "[" LIST@1..9 @@ -13,7 +13,7 @@ JS_MODULE@0..65 R_BRACK@9..10 "]" SEMICOLON@10..11 ";" WHITESPACE@11..12 "\n" - EXPR_STMT@12..18 + JS_EXPRESSION_STATEMENT@12..18 ARRAY_EXPR@12..17 L_BRACK@12..13 "[" LIST@13..16 @@ -22,7 +22,7 @@ JS_MODULE@0..65 R_BRACK@16..17 "]" SEMICOLON@17..18 ";" WHITESPACE@18..19 "\n" - EXPR_STMT@19..26 + JS_EXPRESSION_STATEMENT@19..26 ARRAY_EXPR@19..25 L_BRACK@19..20 "[" LIST@20..24 @@ -32,7 +32,7 @@ JS_MODULE@0..65 R_BRACK@24..25 "]" SEMICOLON@25..26 ";" WHITESPACE@26..27 "\n" - EXPR_STMT@27..34 + JS_EXPRESSION_STATEMENT@27..34 ARRAY_EXPR@27..33 L_BRACK@27..28 "[" LIST@28..32 @@ -42,7 +42,7 @@ JS_MODULE@0..65 R_BRACK@32..33 "]" SEMICOLON@33..34 ";" WHITESPACE@34..35 "\n" - EXPR_STMT@35..50 + JS_EXPRESSION_STATEMENT@35..50 ARRAY_EXPR@35..49 L_BRACK@35..36 "[" LIST@36..48 @@ -60,7 +60,7 @@ JS_MODULE@0..65 R_BRACK@48..49 "]" SEMICOLON@49..50 ";" WHITESPACE@50..51 "\n" - EXPR_STMT@51..64 + JS_EXPRESSION_STATEMENT@51..64 ARRAY_EXPR@51..63 L_BRACK@51..52 "[" LIST@52..62 diff --git a/crates/rslint_parser/test_data/inline/ok/arrow_expr_single_param.rast b/crates/rslint_parser/test_data/inline/ok/arrow_expr_single_param.rast index c37f1f45b53..3c8739991c5 100644 --- a/crates/rslint_parser/test_data/inline/ok/arrow_expr_single_param.rast +++ b/crates/rslint_parser/test_data/inline/ok/arrow_expr_single_param.rast @@ -1,49 +1,49 @@ JS_MODULE@0..44 LIST@0..43 - EXPR_STMT@0..9 + JS_EXPRESSION_STATEMENT@0..9 ARROW_EXPR@0..9 NAME@0..3 IDENT@0..3 "foo" WHITESPACE@3..4 " " FAT_ARROW@4..6 "=>" WHITESPACE@6..7 " " - BLOCK_STMT@7..9 + JS_BLOCK_STATEMENT@7..9 L_CURLY@7..8 "{" LIST@8..8 R_CURLY@8..9 "}" WHITESPACE@9..10 "\n" - EXPR_STMT@10..21 + JS_EXPRESSION_STATEMENT@10..21 ARROW_EXPR@10..21 NAME@10..15 IDENT@10..15 "yield" WHITESPACE@15..16 " " FAT_ARROW@16..18 "=>" WHITESPACE@18..19 " " - BLOCK_STMT@19..21 + JS_BLOCK_STATEMENT@19..21 L_CURLY@19..20 "{" LIST@20..20 R_CURLY@20..21 "}" WHITESPACE@21..22 "\n" - EXPR_STMT@22..33 + JS_EXPRESSION_STATEMENT@22..33 ARROW_EXPR@22..33 NAME@22..27 IDENT@22..27 "await" WHITESPACE@27..28 " " FAT_ARROW@28..30 "=>" WHITESPACE@30..31 " " - BLOCK_STMT@31..33 + JS_BLOCK_STATEMENT@31..33 L_CURLY@31..32 "{" LIST@32..32 R_CURLY@32..33 "}" WHITESPACE@33..34 "\n" - EXPR_STMT@34..43 + JS_EXPRESSION_STATEMENT@34..43 ARROW_EXPR@34..43 NAME@34..37 IDENT@34..37 "foo" WHITESPACE@37..38 " " FAT_ARROW@38..40 "=>" WHITESPACE@40..41 "\n" - BLOCK_STMT@41..43 + JS_BLOCK_STATEMENT@41..43 L_CURLY@41..42 "{" LIST@42..42 R_CURLY@42..43 "}" diff --git a/crates/rslint_parser/test_data/inline/ok/assign_expr.rast b/crates/rslint_parser/test_data/inline/ok/assign_expr.rast index 69b10f90eb3..15537af20de 100644 --- a/crates/rslint_parser/test_data/inline/ok/assign_expr.rast +++ b/crates/rslint_parser/test_data/inline/ok/assign_expr.rast @@ -1,6 +1,6 @@ JS_MODULE@0..101 LIST@0..100 - EXPR_STMT@0..21 + JS_EXPRESSION_STATEMENT@0..21 ASSIGN_EXPR@0..20 NAME_REF@0..3 IDENT@0..3 "foo" @@ -23,7 +23,7 @@ JS_MODULE@0..101 NUMBER@19..20 "3" SEMICOLON@20..21 ";" WHITESPACE@21..22 "\n" - EXPR_STMT@22..33 + JS_EXPRESSION_STATEMENT@22..33 ASSIGN_EXPR@22..32 NAME_REF@22..25 IDENT@22..25 "foo" @@ -34,7 +34,7 @@ JS_MODULE@0..101 IDENT@29..32 "bar" SEMICOLON@32..33 ";" WHITESPACE@33..34 "\n" - EXPR_STMT@34..51 + JS_EXPRESSION_STATEMENT@34..51 ASSIGN_EXPR@34..50 ARRAY_PATTERN@34..44 L_BRACK@34..35 "[" @@ -55,7 +55,7 @@ JS_MODULE@0..101 IDENT@47..50 "baz" SEMICOLON@50..51 ";" WHITESPACE@51..52 "\n" - EXPR_STMT@52..72 + JS_EXPRESSION_STATEMENT@52..72 GROUPING_EXPR@52..71 L_PAREN@52..53 "(" ASSIGN_EXPR@53..70 @@ -83,7 +83,7 @@ JS_MODULE@0..101 R_PAREN@70..71 ")" SEMICOLON@71..72 ";" WHITESPACE@72..73 "\n" - EXPR_STMT@73..100 + JS_EXPRESSION_STATEMENT@73..100 GROUPING_EXPR@73..99 L_PAREN@73..74 "(" ASSIGN_EXPR@74..98 diff --git a/crates/rslint_parser/test_data/inline/ok/async_arrow_expr.rast b/crates/rslint_parser/test_data/inline/ok/async_arrow_expr.rast index 39b1089c239..6f049a57348 100644 --- a/crates/rslint_parser/test_data/inline/ok/async_arrow_expr.rast +++ b/crates/rslint_parser/test_data/inline/ok/async_arrow_expr.rast @@ -19,7 +19,7 @@ JS_MODULE@0..82 WHITESPACE@17..18 " " FAT_ARROW@18..20 "=>" WHITESPACE@20..21 " " - BLOCK_STMT@21..23 + JS_BLOCK_STATEMENT@21..23 L_CURLY@21..22 "{" LIST@22..22 R_CURLY@22..23 "}" @@ -48,12 +48,12 @@ JS_MODULE@0..82 WHITESPACE@43..44 " " FAT_ARROW@44..46 "=>" WHITESPACE@46..47 " " - BLOCK_STMT@47..49 + JS_BLOCK_STATEMENT@47..49 L_CURLY@47..48 "{" LIST@48..48 R_CURLY@48..49 "}" WHITESPACE@49..50 "\n" - EXPR_STMT@50..81 + JS_EXPRESSION_STATEMENT@50..81 ARROW_EXPR@50..81 ASYNC_KW@50..55 "async" WHITESPACE@55..56 " " diff --git a/crates/rslint_parser/test_data/inline/ok/async_function_expr.rast b/crates/rslint_parser/test_data/inline/ok/async_function_expr.rast index 9cefb692d5c..3f788aefc67 100644 --- a/crates/rslint_parser/test_data/inline/ok/async_function_expr.rast +++ b/crates/rslint_parser/test_data/inline/ok/async_function_expr.rast @@ -20,7 +20,7 @@ JS_MODULE@0..62 LIST@23..23 R_PAREN@23..24 ")" WHITESPACE@24..25 " " - BLOCK_STMT@25..27 + JS_BLOCK_STATEMENT@25..27 L_CURLY@25..26 "{" LIST@26..26 R_CURLY@26..27 "}" @@ -49,7 +49,7 @@ JS_MODULE@0..62 LIST@56..56 R_PAREN@56..57 ")" WHITESPACE@57..58 " " - BLOCK_STMT@58..60 + JS_BLOCK_STATEMENT@58..60 L_CURLY@58..59 "{" LIST@59..59 R_CURLY@59..60 "}" diff --git a/crates/rslint_parser/test_data/inline/ok/async_method.rast b/crates/rslint_parser/test_data/inline/ok/async_method.rast index 777853082ae..f69cba3d279 100644 --- a/crates/rslint_parser/test_data/inline/ok/async_method.rast +++ b/crates/rslint_parser/test_data/inline/ok/async_method.rast @@ -20,7 +20,7 @@ JS_MODULE@0..47 LIST@23..23 R_PAREN@23..24 ")" WHITESPACE@24..25 " " - BLOCK_STMT@25..27 + JS_BLOCK_STATEMENT@25..27 L_CURLY@25..26 "{" LIST@26..26 R_CURLY@26..27 "}" @@ -36,7 +36,7 @@ JS_MODULE@0..47 LIST@40..40 R_PAREN@40..41 ")" WHITESPACE@41..42 " " - BLOCK_STMT@42..44 + JS_BLOCK_STATEMENT@42..44 L_CURLY@42..43 "{" LIST@43..43 R_CURLY@43..44 "}" diff --git a/crates/rslint_parser/test_data/inline/ok/binary_expressions.rast b/crates/rslint_parser/test_data/inline/ok/binary_expressions.rast index f0fa5d3023b..c3be51f5c21 100644 --- a/crates/rslint_parser/test_data/inline/ok/binary_expressions.rast +++ b/crates/rslint_parser/test_data/inline/ok/binary_expressions.rast @@ -1,6 +1,6 @@ JS_MODULE@0..125 LIST@0..124 - EXPR_STMT@0..5 + JS_EXPRESSION_STATEMENT@0..5 BIN_EXPR@0..5 LITERAL@0..1 NUMBER@0..1 "5" @@ -10,7 +10,7 @@ JS_MODULE@0..125 LITERAL@4..5 NUMBER@4..5 "5" WHITESPACE@5..6 "\n" - EXPR_STMT@6..17 + JS_EXPRESSION_STATEMENT@6..17 BIN_EXPR@6..17 LITERAL@6..7 NUMBER@6..7 "6" @@ -26,7 +26,7 @@ JS_MODULE@0..125 LITERAL@16..17 NUMBER@16..17 "7" WHITESPACE@17..18 "\n" - EXPR_STMT@18..39 + JS_EXPRESSION_STATEMENT@18..39 BIN_EXPR@18..39 LITERAL@18..19 NUMBER@18..19 "1" @@ -62,7 +62,7 @@ JS_MODULE@0..125 LITERAL@38..39 NUMBER@38..39 "3" WHITESPACE@39..40 "\n" - EXPR_STMT@40..45 + JS_EXPRESSION_STATEMENT@40..45 BIN_EXPR@40..45 LITERAL@40..41 NUMBER@40..41 "1" @@ -72,7 +72,7 @@ JS_MODULE@0..125 LITERAL@44..45 NUMBER@44..45 "2" WHITESPACE@45..46 "\n" - EXPR_STMT@46..55 + JS_EXPRESSION_STATEMENT@46..55 BIN_EXPR@46..55 LITERAL@46..48 NUMBER@46..48 "74" @@ -82,7 +82,7 @@ JS_MODULE@0..125 NAME_REF@52..55 IDENT@52..55 "foo" WHITESPACE@55..56 "\n" - EXPR_STMT@56..76 + JS_EXPRESSION_STATEMENT@56..76 BIN_EXPR@56..76 NAME_REF@56..59 IDENT@56..59 "foo" @@ -92,7 +92,7 @@ JS_MODULE@0..125 NAME_REF@71..76 IDENT@71..76 "Array" WHITESPACE@76..77 "\n" - EXPR_STMT@77..87 + JS_EXPRESSION_STATEMENT@77..87 BIN_EXPR@77..87 NAME_REF@77..80 IDENT@77..80 "foo" @@ -102,7 +102,7 @@ JS_MODULE@0..125 NAME_REF@84..87 IDENT@84..87 "bar" WHITESPACE@87..88 "\n" - EXPR_STMT@88..101 + JS_EXPRESSION_STATEMENT@88..101 BIN_EXPR@88..101 BIN_EXPR@88..97 BIN_EXPR@88..93 @@ -124,7 +124,7 @@ JS_MODULE@0..125 LITERAL@100..101 NUMBER@100..101 "1" WHITESPACE@101..102 "\n" - EXPR_STMT@102..124 + JS_EXPRESSION_STATEMENT@102..124 BIN_EXPR@102..124 BIN_EXPR@102..107 LITERAL@102..103 diff --git a/crates/rslint_parser/test_data/inline/ok/block_stmt.rast b/crates/rslint_parser/test_data/inline/ok/block_stmt.rast index 09adf7f2931..b91637ff96e 100644 --- a/crates/rslint_parser/test_data/inline/ok/block_stmt.rast +++ b/crates/rslint_parser/test_data/inline/ok/block_stmt.rast @@ -1,20 +1,20 @@ JS_MODULE@0..27 LIST@0..26 - BLOCK_STMT@0..2 + JS_BLOCK_STATEMENT@0..2 L_CURLY@0..1 "{" LIST@1..1 R_CURLY@1..2 "}" WHITESPACE@2..3 "\n" - BLOCK_STMT@3..11 + JS_BLOCK_STATEMENT@3..11 L_CURLY@3..4 "{" LIST@4..10 - BLOCK_STMT@4..10 + JS_BLOCK_STATEMENT@4..10 L_CURLY@4..5 "{" LIST@5..9 - BLOCK_STMT@5..9 + JS_BLOCK_STATEMENT@5..9 L_CURLY@5..6 "{" LIST@6..8 - BLOCK_STMT@6..8 + JS_BLOCK_STATEMENT@6..8 L_CURLY@6..7 "{" LIST@7..7 R_CURLY@7..8 "}" @@ -22,11 +22,11 @@ JS_MODULE@0..27 R_CURLY@9..10 "}" R_CURLY@10..11 "}" WHITESPACE@11..12 "\n" - BLOCK_STMT@12..26 + JS_BLOCK_STATEMENT@12..26 L_CURLY@12..13 "{" WHITESPACE@13..14 " " LIST@14..24 - EXPR_STMT@14..24 + JS_EXPRESSION_STATEMENT@14..24 ASSIGN_EXPR@14..23 NAME_REF@14..17 IDENT@14..17 "foo" diff --git a/crates/rslint_parser/test_data/inline/ok/bracket_expr.rast b/crates/rslint_parser/test_data/inline/ok/bracket_expr.rast index 86956f2c0e5..5c526c36778 100644 --- a/crates/rslint_parser/test_data/inline/ok/bracket_expr.rast +++ b/crates/rslint_parser/test_data/inline/ok/bracket_expr.rast @@ -1,6 +1,6 @@ JS_MODULE@0..56 LIST@0..55 - EXPR_STMT@0..8 + JS_EXPRESSION_STATEMENT@0..8 BRACKET_EXPR@0..8 NAME_REF@0..3 IDENT@0..3 "foo" @@ -9,7 +9,7 @@ JS_MODULE@0..56 IDENT@4..7 "bar" R_BRACK@7..8 "]" WHITESPACE@8..9 "\n" - EXPR_STMT@9..19 + JS_EXPRESSION_STATEMENT@9..19 BRACKET_EXPR@9..19 NAME_REF@9..12 IDENT@9..12 "foo" @@ -24,7 +24,7 @@ JS_MODULE@0..56 NUMBER@17..18 "5" R_BRACK@18..19 "]" WHITESPACE@19..20 "\n" - EXPR_STMT@20..30 + JS_EXPRESSION_STATEMENT@20..30 BRACKET_EXPR@20..30 NAME_REF@20..23 IDENT@20..23 "foo" @@ -33,7 +33,7 @@ JS_MODULE@0..56 STRING@24..29 "\"bar\"" R_BRACK@29..30 "]" WHITESPACE@30..31 "\n" - EXPR_STMT@31..44 + JS_EXPRESSION_STATEMENT@31..44 BRACKET_EXPR@31..44 BRACKET_EXPR@31..39 NAME_REF@31..34 @@ -47,7 +47,7 @@ JS_MODULE@0..56 IDENT@40..43 "baz" R_BRACK@43..44 "]" WHITESPACE@44..45 "\n" - EXPR_STMT@45..55 + JS_EXPRESSION_STATEMENT@45..55 BRACKET_EXPR@45..55 NAME_REF@45..48 IDENT@45..48 "foo" diff --git a/crates/rslint_parser/test_data/inline/ok/break_stmt.rast b/crates/rslint_parser/test_data/inline/ok/break_stmt.rast index c1ea8c0f904..209579b91a0 100644 --- a/crates/rslint_parser/test_data/inline/ok/break_stmt.rast +++ b/crates/rslint_parser/test_data/inline/ok/break_stmt.rast @@ -1,21 +1,19 @@ JS_MODULE@0..46 LIST@0..45 - LABELLED_STMT@0..7 - NAME@0..3 - IDENT@0..3 "foo" + JS_LABELED_STATEMENT@0..7 + IDENT@0..3 "foo" COLON@3..4 ":" WHITESPACE@4..5 " " - BLOCK_STMT@5..7 + JS_BLOCK_STATEMENT@5..7 L_CURLY@5..6 "{" LIST@6..6 R_CURLY@6..7 "}" WHITESPACE@7..8 "\n" - LABELLED_STMT@8..16 - NAME@8..12 - IDENT@8..12 "rust" + JS_LABELED_STATEMENT@8..16 + IDENT@8..12 "rust" COLON@12..13 ":" WHITESPACE@13..14 " " - BLOCK_STMT@14..16 + JS_BLOCK_STATEMENT@14..16 L_CURLY@14..15 "{" LIST@15..15 R_CURLY@15..16 "}" diff --git a/crates/rslint_parser/test_data/inline/ok/class_empty_element.rast b/crates/rslint_parser/test_data/inline/ok/class_empty_element.rast index ae5aa8865ac..22e98c51143 100644 --- a/crates/rslint_parser/test_data/inline/ok/class_empty_element.rast +++ b/crates/rslint_parser/test_data/inline/ok/class_empty_element.rast @@ -10,25 +10,25 @@ JS_MODULE@0..41 L_CURLY@10..11 "{" WHITESPACE@11..12 " " LIST@12..39 - EMPTY_STMT@12..13 + JS_EMPTY_STATEMENT@12..13 SEMICOLON@12..13 ";" - EMPTY_STMT@13..14 + JS_EMPTY_STATEMENT@13..14 SEMICOLON@13..14 ";" - EMPTY_STMT@14..15 + JS_EMPTY_STATEMENT@14..15 SEMICOLON@14..15 ";" - EMPTY_STMT@15..16 + JS_EMPTY_STATEMENT@15..16 SEMICOLON@15..16 ";" - EMPTY_STMT@16..17 + JS_EMPTY_STATEMENT@16..17 SEMICOLON@16..17 ";" - EMPTY_STMT@17..18 + JS_EMPTY_STATEMENT@17..18 SEMICOLON@17..18 ";" - EMPTY_STMT@18..19 + JS_EMPTY_STATEMENT@18..19 SEMICOLON@18..19 ";" - EMPTY_STMT@19..20 + JS_EMPTY_STATEMENT@19..20 SEMICOLON@19..20 ";" - EMPTY_STMT@20..21 + JS_EMPTY_STATEMENT@20..21 SEMICOLON@20..21 ";" - EMPTY_STMT@21..22 + JS_EMPTY_STATEMENT@21..22 SEMICOLON@21..22 ";" WHITESPACE@22..23 " " GETTER@23..35 @@ -41,17 +41,17 @@ JS_MODULE@0..41 LIST@31..31 R_PAREN@31..32 ")" WHITESPACE@32..33 " " - BLOCK_STMT@33..35 + JS_BLOCK_STATEMENT@33..35 L_CURLY@33..34 "{" LIST@34..34 R_CURLY@34..35 "}" - EMPTY_STMT@35..36 + JS_EMPTY_STATEMENT@35..36 SEMICOLON@35..36 ";" - EMPTY_STMT@36..37 + JS_EMPTY_STATEMENT@36..37 SEMICOLON@36..37 ";" - EMPTY_STMT@37..38 + JS_EMPTY_STATEMENT@37..38 SEMICOLON@37..38 ";" - EMPTY_STMT@38..39 + JS_EMPTY_STATEMENT@38..39 SEMICOLON@38..39 ";" R_CURLY@39..40 "}" WHITESPACE@40..41 "\n" diff --git a/crates/rslint_parser/test_data/inline/ok/class_expr.rast b/crates/rslint_parser/test_data/inline/ok/class_expr.rast index 5a4194c8488..bdf3b802df2 100644 --- a/crates/rslint_parser/test_data/inline/ok/class_expr.rast +++ b/crates/rslint_parser/test_data/inline/ok/class_expr.rast @@ -49,14 +49,14 @@ JS_MODULE@0..72 LIST@51..51 R_PAREN@51..52 ")" WHITESPACE@52..53 " " - BLOCK_STMT@53..55 + JS_BLOCK_STATEMENT@53..55 L_CURLY@53..54 "{" LIST@54..54 R_CURLY@54..55 "}" WHITESPACE@55..56 "\n" R_CURLY@56..57 "}" WHITESPACE@57..58 "\n" - EXPR_STMT@58..71 + JS_EXPRESSION_STATEMENT@58..71 BRACKET_EXPR@58..71 NAME_REF@58..61 IDENT@58..61 "foo" diff --git a/crates/rslint_parser/test_data/inline/ok/conditional_expr.rast b/crates/rslint_parser/test_data/inline/ok/conditional_expr.rast index 44047df3754..80681e0c19d 100644 --- a/crates/rslint_parser/test_data/inline/ok/conditional_expr.rast +++ b/crates/rslint_parser/test_data/inline/ok/conditional_expr.rast @@ -1,6 +1,6 @@ JS_MODULE@0..44 LIST@0..43 - EXPR_STMT@0..15 + JS_EXPRESSION_STATEMENT@0..15 COND_EXPR@0..15 NAME_REF@0..3 IDENT@0..3 "foo" @@ -15,7 +15,7 @@ JS_MODULE@0..44 NAME_REF@12..15 IDENT@12..15 "baz" WHITESPACE@15..16 "\n" - EXPR_STMT@16..43 + JS_EXPRESSION_STATEMENT@16..43 COND_EXPR@16..43 NAME_REF@16..19 IDENT@16..19 "foo" diff --git a/crates/rslint_parser/test_data/inline/ok/continue_stmt.rast b/crates/rslint_parser/test_data/inline/ok/continue_stmt.rast index 5325188be25..957e6763479 100644 --- a/crates/rslint_parser/test_data/inline/ok/continue_stmt.rast +++ b/crates/rslint_parser/test_data/inline/ok/continue_stmt.rast @@ -1,11 +1,10 @@ JS_MODULE@0..64 LIST@0..63 - LABELLED_STMT@0..7 - NAME@0..3 - IDENT@0..3 "foo" + JS_LABELED_STATEMENT@0..7 + IDENT@0..3 "foo" COLON@3..4 ":" WHITESPACE@4..5 " " - BLOCK_STMT@5..7 + JS_BLOCK_STATEMENT@5..7 L_CURLY@5..6 "{" LIST@6..6 R_CURLY@6..7 "}" @@ -19,7 +18,7 @@ JS_MODULE@0..64 TRUE_KW@15..19 "true" R_PAREN@19..20 ")" WHITESPACE@20..21 " " - BLOCK_STMT@21..63 + JS_BLOCK_STATEMENT@21..63 L_CURLY@21..22 "{" WHITESPACE@22..25 "\n " LIST@25..61 diff --git a/crates/rslint_parser/test_data/inline/ok/debugger_stmt.rast b/crates/rslint_parser/test_data/inline/ok/debugger_stmt.rast index 0de4d7d6807..3eeafd12956 100644 --- a/crates/rslint_parser/test_data/inline/ok/debugger_stmt.rast +++ b/crates/rslint_parser/test_data/inline/ok/debugger_stmt.rast @@ -1,6 +1,6 @@ JS_MODULE@0..10 LIST@0..9 - DEBUGGER_STMT@0..9 + JS_DEBUGGER_STATEMENT@0..9 DEBUGGER_KW@0..8 "debugger" SEMICOLON@8..9 ";" WHITESPACE@9..10 "\n" diff --git a/crates/rslint_parser/test_data/inline/ok/dot_expr.rast b/crates/rslint_parser/test_data/inline/ok/dot_expr.rast index 10ec1d625a7..85052aee03d 100644 --- a/crates/rslint_parser/test_data/inline/ok/dot_expr.rast +++ b/crates/rslint_parser/test_data/inline/ok/dot_expr.rast @@ -1,6 +1,6 @@ JS_MODULE@0..54 LIST@0..53 - EXPR_STMT@0..7 + JS_EXPRESSION_STATEMENT@0..7 DOT_EXPR@0..7 NAME_REF@0..3 IDENT@0..3 "foo" @@ -8,7 +8,7 @@ JS_MODULE@0..54 NAME@4..7 IDENT@4..7 "bar" WHITESPACE@7..8 "\n" - EXPR_STMT@8..17 + JS_EXPRESSION_STATEMENT@8..17 DOT_EXPR@8..17 NAME_REF@8..11 IDENT@8..11 "foo" @@ -16,7 +16,7 @@ JS_MODULE@0..54 NAME@12..17 IDENT@12..17 "await" WHITESPACE@17..18 "\n" - EXPR_STMT@18..27 + JS_EXPRESSION_STATEMENT@18..27 DOT_EXPR@18..27 NAME_REF@18..21 IDENT@18..21 "foo" @@ -24,7 +24,7 @@ JS_MODULE@0..54 NAME@22..27 IDENT@22..27 "yield" WHITESPACE@27..28 "\n" - EXPR_STMT@28..35 + JS_EXPRESSION_STATEMENT@28..35 DOT_EXPR@28..35 NAME_REF@28..31 IDENT@28..31 "foo" @@ -32,7 +32,7 @@ JS_MODULE@0..54 NAME@32..35 IDENT@32..35 "for" WHITESPACE@35..36 "\n" - EXPR_STMT@36..44 + JS_EXPRESSION_STATEMENT@36..44 DOT_EXPR@36..44 NAME_REF@36..39 IDENT@36..39 "foo" @@ -40,7 +40,7 @@ JS_MODULE@0..54 NAME@41..44 IDENT@41..44 "for" WHITESPACE@44..45 "\n" - EXPR_STMT@45..53 + JS_EXPRESSION_STATEMENT@45..53 DOT_EXPR@45..53 NAME_REF@45..48 IDENT@45..48 "foo" diff --git a/crates/rslint_parser/test_data/inline/ok/empty_stmt.rast b/crates/rslint_parser/test_data/inline/ok/empty_stmt.rast index 907214ace86..4c8a6e426dc 100644 --- a/crates/rslint_parser/test_data/inline/ok/empty_stmt.rast +++ b/crates/rslint_parser/test_data/inline/ok/empty_stmt.rast @@ -1,5 +1,5 @@ JS_MODULE@0..2 LIST@0..1 - EMPTY_STMT@0..1 + JS_EMPTY_STATEMENT@0..1 SEMICOLON@0..1 ";" WHITESPACE@1..2 "\n" diff --git a/crates/rslint_parser/test_data/inline/ok/for_stmt.rast b/crates/rslint_parser/test_data/inline/ok/for_stmt.rast index 85f618ea2d3..33d96ba6f8f 100644 --- a/crates/rslint_parser/test_data/inline/ok/for_stmt.rast +++ b/crates/rslint_parser/test_data/inline/ok/for_stmt.rast @@ -38,7 +38,7 @@ JS_MODULE@0..95 PLUS2@25..27 "++" R_PAREN@27..28 ")" WHITESPACE@28..29 " " - BLOCK_STMT@29..31 + JS_BLOCK_STATEMENT@29..31 L_CURLY@29..30 "{" LIST@30..30 R_CURLY@30..31 "}" @@ -76,7 +76,7 @@ JS_MODULE@0..95 R_CURLY@58..59 "}" R_PAREN@59..60 ")" WHITESPACE@60..61 " " - BLOCK_STMT@61..63 + JS_BLOCK_STATEMENT@61..63 L_CURLY@61..62 "{" LIST@62..62 R_CURLY@62..63 "}" @@ -97,7 +97,7 @@ JS_MODULE@0..95 R_CURLY@77..78 "}" R_PAREN@78..79 ")" WHITESPACE@79..80 " " - BLOCK_STMT@80..82 + JS_BLOCK_STATEMENT@80..82 L_CURLY@80..81 "{" LIST@81..81 R_CURLY@81..82 "}" @@ -110,7 +110,7 @@ JS_MODULE@0..95 SEMICOLON@89..90 ";" R_PAREN@90..91 ")" WHITESPACE@91..92 " " - BLOCK_STMT@92..94 + JS_BLOCK_STATEMENT@92..94 L_CURLY@92..93 "{" LIST@93..93 R_CURLY@93..94 "}" diff --git a/crates/rslint_parser/test_data/inline/ok/function_decl.rast b/crates/rslint_parser/test_data/inline/ok/function_decl.rast index c0cd84423c5..506133ebf4b 100644 --- a/crates/rslint_parser/test_data/inline/ok/function_decl.rast +++ b/crates/rslint_parser/test_data/inline/ok/function_decl.rast @@ -10,7 +10,7 @@ JS_MODULE@0..142 LIST@13..13 R_PAREN@13..14 ")" WHITESPACE@14..15 " " - BLOCK_STMT@15..17 + JS_BLOCK_STATEMENT@15..17 L_CURLY@15..16 "{" LIST@16..16 R_CURLY@16..17 "}" @@ -26,7 +26,7 @@ JS_MODULE@0..142 LIST@32..32 R_PAREN@32..33 ")" WHITESPACE@33..34 " " - BLOCK_STMT@34..36 + JS_BLOCK_STATEMENT@34..36 L_CURLY@34..35 "{" LIST@35..35 R_CURLY@35..36 "}" @@ -44,7 +44,7 @@ JS_MODULE@0..142 IDENT@50..55 "await" R_PAREN@55..56 ")" WHITESPACE@56..57 " " - BLOCK_STMT@57..59 + JS_BLOCK_STATEMENT@57..59 L_CURLY@57..58 "{" LIST@58..58 R_CURLY@58..59 "}" @@ -62,7 +62,7 @@ JS_MODULE@0..142 LIST@80..80 R_PAREN@80..81 ")" WHITESPACE@81..82 " " - BLOCK_STMT@82..84 + JS_BLOCK_STATEMENT@82..84 L_CURLY@82..83 "{" LIST@83..83 R_CURLY@83..84 "}" @@ -79,7 +79,7 @@ JS_MODULE@0..142 LIST@104..104 R_PAREN@104..105 ")" WHITESPACE@105..106 " " - BLOCK_STMT@106..108 + JS_BLOCK_STATEMENT@106..108 L_CURLY@106..107 "{" LIST@107..107 R_CURLY@107..108 "}" @@ -95,11 +95,11 @@ JS_MODULE@0..142 LIST@123..123 R_PAREN@123..124 ")" WHITESPACE@124..125 " " - BLOCK_STMT@125..141 + JS_BLOCK_STATEMENT@125..141 L_CURLY@125..126 "{" WHITESPACE@126..129 "\n " LIST@129..139 - EXPR_STMT@129..139 + JS_EXPRESSION_STATEMENT@129..139 YIELD_EXPR@129..138 YIELD_KW@129..134 "yield" WHITESPACE@134..135 " " diff --git a/crates/rslint_parser/test_data/inline/ok/function_expr.rast b/crates/rslint_parser/test_data/inline/ok/function_expr.rast index caf81b1a696..7be8b3eaf35 100644 --- a/crates/rslint_parser/test_data/inline/ok/function_expr.rast +++ b/crates/rslint_parser/test_data/inline/ok/function_expr.rast @@ -18,7 +18,7 @@ JS_MODULE@0..48 LIST@17..17 R_PAREN@17..18 ")" WHITESPACE@18..19 " " - BLOCK_STMT@19..21 + JS_BLOCK_STATEMENT@19..21 L_CURLY@19..20 "{" LIST@20..20 R_CURLY@20..21 "}" @@ -44,7 +44,7 @@ JS_MODULE@0..48 LIST@43..43 R_PAREN@43..44 ")" WHITESPACE@44..45 " " - BLOCK_STMT@45..47 + JS_BLOCK_STATEMENT@45..47 L_CURLY@45..46 "{" LIST@46..46 R_CURLY@46..47 "}" diff --git a/crates/rslint_parser/test_data/inline/ok/grouping_expr.rast b/crates/rslint_parser/test_data/inline/ok/grouping_expr.rast index fea7489c59d..cdae1600c80 100644 --- a/crates/rslint_parser/test_data/inline/ok/grouping_expr.rast +++ b/crates/rslint_parser/test_data/inline/ok/grouping_expr.rast @@ -1,6 +1,6 @@ JS_MODULE@0..14 LIST@0..13 - EXPR_STMT@0..13 + JS_EXPRESSION_STATEMENT@0..13 CALL_EXPR@0..13 GROUPING_EXPR@0..7 L_PAREN@0..1 "(" diff --git a/crates/rslint_parser/test_data/inline/ok/identifier_reference.rast b/crates/rslint_parser/test_data/inline/ok/identifier_reference.rast index 1edc0522fbf..fafdfb8d48e 100644 --- a/crates/rslint_parser/test_data/inline/ok/identifier_reference.rast +++ b/crates/rslint_parser/test_data/inline/ok/identifier_reference.rast @@ -1,16 +1,16 @@ JS_MODULE@0..19 LIST@0..18 - EXPR_STMT@0..4 + JS_EXPRESSION_STATEMENT@0..4 NAME_REF@0..3 IDENT@0..3 "foo" SEMICOLON@3..4 ";" WHITESPACE@4..5 "\n" - EXPR_STMT@5..11 + JS_EXPRESSION_STATEMENT@5..11 NAME_REF@5..10 IDENT@5..10 "yield" SEMICOLON@10..11 ";" WHITESPACE@11..12 "\n" - EXPR_STMT@12..18 + JS_EXPRESSION_STATEMENT@12..18 NAME_REF@12..17 IDENT@12..17 "await" SEMICOLON@17..18 ";" diff --git a/crates/rslint_parser/test_data/inline/ok/if_stmt.rast b/crates/rslint_parser/test_data/inline/ok/if_stmt.rast index 9f1a93807ad..884a4eb9f3a 100644 --- a/crates/rslint_parser/test_data/inline/ok/if_stmt.rast +++ b/crates/rslint_parser/test_data/inline/ok/if_stmt.rast @@ -9,14 +9,14 @@ JS_MODULE@0..88 TRUE_KW@4..8 "true" R_PAREN@8..9 ")" WHITESPACE@9..10 " " - BLOCK_STMT@10..12 + JS_BLOCK_STATEMENT@10..12 L_CURLY@10..11 "{" LIST@11..11 R_CURLY@11..12 "}" WHITESPACE@12..13 " " ELSE_KW@13..17 "else" WHITESPACE@17..18 " " - BLOCK_STMT@18..20 + JS_BLOCK_STATEMENT@18..20 L_CURLY@18..19 "{" LIST@19..19 R_CURLY@19..20 "}" @@ -30,7 +30,7 @@ JS_MODULE@0..88 TRUE_KW@25..29 "true" R_PAREN@29..30 ")" WHITESPACE@30..31 " " - BLOCK_STMT@31..33 + JS_BLOCK_STATEMENT@31..33 L_CURLY@31..32 "{" LIST@32..32 R_CURLY@32..33 "}" @@ -44,7 +44,7 @@ JS_MODULE@0..88 TRUE_KW@38..42 "true" R_PAREN@42..43 ")" WHITESPACE@43..44 " " - EXPR_STMT@44..49 + JS_EXPRESSION_STATEMENT@44..49 LITERAL@44..49 FALSE_KW@44..49 "false" WHITESPACE@49..50 "\n" @@ -57,7 +57,7 @@ JS_MODULE@0..88 IDENT@54..57 "bar" R_PAREN@57..58 ")" WHITESPACE@58..59 " " - BLOCK_STMT@59..61 + JS_BLOCK_STATEMENT@59..61 L_CURLY@59..60 "{" LIST@60..60 R_CURLY@60..61 "}" @@ -73,14 +73,14 @@ JS_MODULE@0..88 TRUE_KW@71..75 "true" R_PAREN@75..76 ")" WHITESPACE@76..77 " " - BLOCK_STMT@77..79 + JS_BLOCK_STATEMENT@77..79 L_CURLY@77..78 "{" LIST@78..78 R_CURLY@78..79 "}" WHITESPACE@79..80 " " ELSE_KW@80..84 "else" WHITESPACE@84..85 " " - BLOCK_STMT@85..87 + JS_BLOCK_STATEMENT@85..87 L_CURLY@85..86 "{" LIST@86..86 R_CURLY@86..87 "}" diff --git a/crates/rslint_parser/test_data/inline/ok/import_call.rast b/crates/rslint_parser/test_data/inline/ok/import_call.rast index 4f81e0840eb..9feb9ec74df 100644 --- a/crates/rslint_parser/test_data/inline/ok/import_call.rast +++ b/crates/rslint_parser/test_data/inline/ok/import_call.rast @@ -1,6 +1,6 @@ JS_MODULE@0..14 LIST@0..13 - EXPR_STMT@0..13 + JS_EXPRESSION_STATEMENT@0..13 IMPORT_CALL@0..13 IMPORT_KW@0..6 "import" L_PAREN@6..7 "(" diff --git a/crates/rslint_parser/test_data/inline/ok/import_meta.rast b/crates/rslint_parser/test_data/inline/ok/import_meta.rast index 4bc6e9e99a7..c7d7db3216a 100644 --- a/crates/rslint_parser/test_data/inline/ok/import_meta.rast +++ b/crates/rslint_parser/test_data/inline/ok/import_meta.rast @@ -1,6 +1,6 @@ JS_MODULE@0..12 LIST@0..11 - EXPR_STMT@0..11 + JS_EXPRESSION_STATEMENT@0..11 IMPORT_META@0..11 IMPORT_KW@0..6 "import" DOT@6..7 "." diff --git a/crates/rslint_parser/test_data/inline/ok/literals.rast b/crates/rslint_parser/test_data/inline/ok/literals.rast index 445e350826d..709dd9e4037 100644 --- a/crates/rslint_parser/test_data/inline/ok/literals.rast +++ b/crates/rslint_parser/test_data/inline/ok/literals.rast @@ -1,30 +1,30 @@ JS_MODULE@0..33 LIST@0..32 - EXPR_STMT@0..1 + JS_EXPRESSION_STATEMENT@0..1 LITERAL@0..1 NUMBER@0..1 "5" WHITESPACE@1..2 "\n" - EXPR_STMT@2..6 + JS_EXPRESSION_STATEMENT@2..6 LITERAL@2..6 TRUE_KW@2..6 "true" WHITESPACE@6..7 "\n" - EXPR_STMT@7..12 + JS_EXPRESSION_STATEMENT@7..12 LITERAL@7..12 FALSE_KW@7..12 "false" WHITESPACE@12..13 "\n" - EXPR_STMT@13..15 + JS_EXPRESSION_STATEMENT@13..15 LITERAL@13..15 NUMBER@13..15 "5n" WHITESPACE@15..16 "\n" - EXPR_STMT@16..21 + JS_EXPRESSION_STATEMENT@16..21 LITERAL@16..21 STRING@16..21 "\"foo\"" WHITESPACE@21..22 "\n" - EXPR_STMT@22..27 + JS_EXPRESSION_STATEMENT@22..27 LITERAL@22..27 STRING@22..27 "'bar'" WHITESPACE@27..28 "\n" - EXPR_STMT@28..32 + JS_EXPRESSION_STATEMENT@28..32 LITERAL@28..32 NULL_KW@28..32 "null" WHITESPACE@32..33 "\n" diff --git a/crates/rslint_parser/test_data/inline/ok/method_getter.rast b/crates/rslint_parser/test_data/inline/ok/method_getter.rast index b3479d58782..2352c9263c3 100644 --- a/crates/rslint_parser/test_data/inline/ok/method_getter.rast +++ b/crates/rslint_parser/test_data/inline/ok/method_getter.rast @@ -20,7 +20,7 @@ JS_MODULE@0..28 LIST@21..21 R_PAREN@21..22 ")" WHITESPACE@22..23 " " - BLOCK_STMT@23..25 + JS_BLOCK_STATEMENT@23..25 L_CURLY@23..24 "{" LIST@24..24 R_CURLY@24..25 "}" diff --git a/crates/rslint_parser/test_data/inline/ok/method_setter.rast b/crates/rslint_parser/test_data/inline/ok/method_setter.rast index 426e1fe3ad0..68710430a29 100644 --- a/crates/rslint_parser/test_data/inline/ok/method_setter.rast +++ b/crates/rslint_parser/test_data/inline/ok/method_setter.rast @@ -20,7 +20,7 @@ JS_MODULE@0..28 LIST@21..21 R_PAREN@21..22 ")" WHITESPACE@22..23 " " - BLOCK_STMT@23..25 + JS_BLOCK_STATEMENT@23..25 L_CURLY@23..24 "{" LIST@24..24 R_CURLY@24..25 "}" diff --git a/crates/rslint_parser/test_data/inline/ok/new_exprs.rast b/crates/rslint_parser/test_data/inline/ok/new_exprs.rast index a8cb5cfdefa..b9ebf126b28 100644 --- a/crates/rslint_parser/test_data/inline/ok/new_exprs.rast +++ b/crates/rslint_parser/test_data/inline/ok/new_exprs.rast @@ -1,6 +1,6 @@ JS_MODULE@0..113 LIST@0..112 - EXPR_STMT@0..9 + JS_EXPRESSION_STATEMENT@0..9 NEW_EXPR@0..9 NEW_KW@0..3 "new" WHITESPACE@3..4 " " @@ -11,7 +11,7 @@ JS_MODULE@0..113 LIST@8..8 R_PAREN@8..9 ")" WHITESPACE@9..10 "\n" - EXPR_STMT@10..18 + JS_EXPRESSION_STATEMENT@10..18 NEW_EXPR@10..17 NEW_KW@10..13 "new" WHITESPACE@13..14 " " @@ -19,13 +19,13 @@ JS_MODULE@0..113 IDENT@14..17 "foo" SEMICOLON@17..18 ";" WHITESPACE@18..19 "\n" - EXPR_STMT@19..29 + JS_EXPRESSION_STATEMENT@19..29 NEW_TARGET@19..29 NEW_KW@19..22 "new" DOT@22..23 "." IDENT@23..29 "target" WHITESPACE@29..30 "\n" - EXPR_STMT@30..52 + JS_EXPRESSION_STATEMENT@30..52 NEW_EXPR@30..51 NEW_KW@30..33 "new" WHITESPACE@33..34 " " @@ -46,7 +46,7 @@ JS_MODULE@0..113 R_PAREN@50..51 ")" SEMICOLON@51..52 ";" WHITESPACE@52..53 "\n" - EXPR_STMT@53..112 + JS_EXPRESSION_STATEMENT@53..112 NEW_EXPR@53..112 NEW_KW@53..56 "new" WHITESPACE@56..57 " " @@ -96,7 +96,7 @@ JS_MODULE@0..113 WHITESPACE@94..95 " " FAT_ARROW@95..97 "=>" WHITESPACE@97..98 " " - BLOCK_STMT@98..100 + JS_BLOCK_STATEMENT@98..100 L_CURLY@98..99 "{" LIST@99..99 R_CURLY@99..100 "}" diff --git a/crates/rslint_parser/test_data/inline/ok/object_expr_async_method.rast b/crates/rslint_parser/test_data/inline/ok/object_expr_async_method.rast index 867f84cbbd9..158b7e5d49e 100644 --- a/crates/rslint_parser/test_data/inline/ok/object_expr_async_method.rast +++ b/crates/rslint_parser/test_data/inline/ok/object_expr_async_method.rast @@ -25,7 +25,7 @@ JS_MODULE@0..48 LIST@22..22 R_PAREN@22..23 ")" WHITESPACE@23..24 " " - BLOCK_STMT@24..26 + JS_BLOCK_STATEMENT@24..26 L_CURLY@24..25 "{" LIST@25..25 R_CURLY@25..26 "}" @@ -42,7 +42,7 @@ JS_MODULE@0..48 LIST@41..41 R_PAREN@41..42 ")" WHITESPACE@42..43 " " - BLOCK_STMT@43..45 + JS_BLOCK_STATEMENT@43..45 L_CURLY@43..44 "{" LIST@44..44 R_CURLY@44..45 "}" diff --git a/crates/rslint_parser/test_data/inline/ok/object_expr_generator_method.rast b/crates/rslint_parser/test_data/inline/ok/object_expr_generator_method.rast index 35a5f29ae85..5d07870dfcd 100644 --- a/crates/rslint_parser/test_data/inline/ok/object_expr_generator_method.rast +++ b/crates/rslint_parser/test_data/inline/ok/object_expr_generator_method.rast @@ -24,7 +24,7 @@ JS_MODULE@0..22 LIST@15..15 R_PAREN@15..16 ")" WHITESPACE@16..17 " " - BLOCK_STMT@17..19 + JS_BLOCK_STATEMENT@17..19 L_CURLY@17..18 "{" LIST@18..18 R_CURLY@18..19 "}" diff --git a/crates/rslint_parser/test_data/inline/ok/object_expr_getter_setter.rast b/crates/rslint_parser/test_data/inline/ok/object_expr_getter_setter.rast index a56745dcc99..e42a0e23fa4 100644 --- a/crates/rslint_parser/test_data/inline/ok/object_expr_getter_setter.rast +++ b/crates/rslint_parser/test_data/inline/ok/object_expr_getter_setter.rast @@ -25,11 +25,11 @@ JS_MODULE@0..43 LIST@19..19 R_PAREN@19..20 ")" WHITESPACE@20..21 " " - BLOCK_STMT@21..40 + JS_BLOCK_STATEMENT@21..40 L_CURLY@21..22 "{" WHITESPACE@22..26 "\n " LIST@26..37 - RETURN_STMT@26..37 + JS_RETURN_STATEMENT@26..37 RETURN_KW@26..32 "return" WHITESPACE@32..33 " " NAME_REF@33..36 diff --git a/crates/rslint_parser/test_data/inline/ok/object_expr_getter_setter_computed.rast b/crates/rslint_parser/test_data/inline/ok/object_expr_getter_setter_computed.rast index 6b7646af0aa..07753a2b6f3 100644 --- a/crates/rslint_parser/test_data/inline/ok/object_expr_getter_setter_computed.rast +++ b/crates/rslint_parser/test_data/inline/ok/object_expr_getter_setter_computed.rast @@ -28,11 +28,11 @@ JS_MODULE@0..48 LIST@22..22 R_PAREN@22..23 ")" WHITESPACE@23..24 " " - BLOCK_STMT@24..45 + JS_BLOCK_STATEMENT@24..45 L_CURLY@24..25 "{" WHITESPACE@25..30 "\n " LIST@30..41 - RETURN_STMT@30..41 + JS_RETURN_STATEMENT@30..41 RETURN_KW@30..36 "return" WHITESPACE@36..37 " " NAME_REF@37..40 diff --git a/crates/rslint_parser/test_data/inline/ok/object_expr_method.rast b/crates/rslint_parser/test_data/inline/ok/object_expr_method.rast index 90d7f7238b1..d14abc22250 100644 --- a/crates/rslint_parser/test_data/inline/ok/object_expr_method.rast +++ b/crates/rslint_parser/test_data/inline/ok/object_expr_method.rast @@ -23,7 +23,7 @@ JS_MODULE@0..23 LIST@15..15 R_PAREN@15..16 ")" WHITESPACE@16..17 " " - BLOCK_STMT@17..19 + JS_BLOCK_STATEMENT@17..19 L_CURLY@17..18 "{" LIST@18..18 R_CURLY@18..19 "}" diff --git a/crates/rslint_parser/test_data/inline/ok/paren_or_arrow_expr.rast b/crates/rslint_parser/test_data/inline/ok/paren_or_arrow_expr.rast index e77e78c57ff..4451f0215bc 100644 --- a/crates/rslint_parser/test_data/inline/ok/paren_or_arrow_expr.rast +++ b/crates/rslint_parser/test_data/inline/ok/paren_or_arrow_expr.rast @@ -1,6 +1,6 @@ JS_MODULE@0..85 LIST@0..84 - EXPR_STMT@0..6 + JS_EXPRESSION_STATEMENT@0..6 GROUPING_EXPR@0..5 L_PAREN@0..1 "(" NAME_REF@1..4 @@ -8,7 +8,7 @@ JS_MODULE@0..85 R_PAREN@4..5 ")" SEMICOLON@5..6 ";" WHITESPACE@6..7 "\n" - EXPR_STMT@7..19 + JS_EXPRESSION_STATEMENT@7..19 ARROW_EXPR@7..18 PARAMETER_LIST@7..12 L_PAREN@7..8 "(" @@ -20,13 +20,13 @@ JS_MODULE@0..85 WHITESPACE@12..13 " " FAT_ARROW@13..15 "=>" WHITESPACE@15..16 " " - BLOCK_STMT@16..18 + JS_BLOCK_STATEMENT@16..18 L_CURLY@16..17 "{" LIST@17..17 R_CURLY@17..18 "}" SEMICOLON@18..19 ";" WHITESPACE@19..20 "\n" - EXPR_STMT@20..28 + JS_EXPRESSION_STATEMENT@20..28 GROUPING_EXPR@20..27 L_PAREN@20..21 "(" BIN_EXPR@21..26 @@ -40,7 +40,7 @@ JS_MODULE@0..85 R_PAREN@26..27 ")" SEMICOLON@27..28 ";" WHITESPACE@28..29 "\n" - EXPR_STMT@29..64 + JS_EXPRESSION_STATEMENT@29..64 ARROW_EXPR@29..63 PARAMETER_LIST@29..57 L_PAREN@29..30 "(" @@ -82,13 +82,13 @@ JS_MODULE@0..85 WHITESPACE@57..58 " " FAT_ARROW@58..60 "=>" WHITESPACE@60..61 " " - BLOCK_STMT@61..63 + JS_BLOCK_STATEMENT@61..63 L_CURLY@61..62 "{" LIST@62..62 R_CURLY@62..63 "}" SEMICOLON@63..64 ";" WHITESPACE@64..65 "\n" - EXPR_STMT@65..84 + JS_EXPRESSION_STATEMENT@65..84 ARROW_EXPR@65..84 PARAMETER_LIST@65..78 L_PAREN@65..66 "(" @@ -107,7 +107,7 @@ JS_MODULE@0..85 WHITESPACE@78..79 " " FAT_ARROW@79..81 "=>" WHITESPACE@81..82 " " - BLOCK_STMT@82..84 + JS_BLOCK_STATEMENT@82..84 L_CURLY@82..83 "{" LIST@83..83 R_CURLY@83..84 "}" diff --git a/crates/rslint_parser/test_data/inline/ok/post_update_expr.rast b/crates/rslint_parser/test_data/inline/ok/post_update_expr.rast index 2d0fb61ba1e..74ac5a43c2c 100644 --- a/crates/rslint_parser/test_data/inline/ok/post_update_expr.rast +++ b/crates/rslint_parser/test_data/inline/ok/post_update_expr.rast @@ -1,12 +1,12 @@ JS_MODULE@0..12 LIST@0..11 - EXPR_STMT@0..5 + JS_EXPRESSION_STATEMENT@0..5 POST_UPDATE_EXPRESSION@0..5 NAME_REF@0..3 IDENT@0..3 "foo" PLUS2@3..5 "++" WHITESPACE@5..6 "\n" - EXPR_STMT@6..11 + JS_EXPRESSION_STATEMENT@6..11 POST_UPDATE_EXPRESSION@6..11 NAME_REF@6..9 IDENT@6..9 "foo" diff --git a/crates/rslint_parser/test_data/inline/ok/pre_update_expr.rast b/crates/rslint_parser/test_data/inline/ok/pre_update_expr.rast index fec853d197f..ba069161244 100644 --- a/crates/rslint_parser/test_data/inline/ok/pre_update_expr.rast +++ b/crates/rslint_parser/test_data/inline/ok/pre_update_expr.rast @@ -1,12 +1,12 @@ JS_MODULE@0..12 LIST@0..11 - EXPR_STMT@0..5 + JS_EXPRESSION_STATEMENT@0..5 PRE_UPDATE_EXPRESSION@0..5 PLUS2@0..2 "++" NAME_REF@2..5 IDENT@2..5 "foo" WHITESPACE@5..6 "\n" - EXPR_STMT@6..11 + JS_EXPRESSION_STATEMENT@6..11 PRE_UPDATE_EXPRESSION@6..11 MINUS2@6..8 "--" NAME_REF@8..11 diff --git a/crates/rslint_parser/test_data/inline/ok/return_stmt.rast b/crates/rslint_parser/test_data/inline/ok/return_stmt.rast index 10776ae7f0e..98e2b5b7125 100644 --- a/crates/rslint_parser/test_data/inline/ok/return_stmt.rast +++ b/crates/rslint_parser/test_data/inline/ok/return_stmt.rast @@ -1,6 +1,6 @@ JS_MODULE@0..43 LIST@0..42 - EXPR_STMT@0..42 + JS_EXPRESSION_STATEMENT@0..42 ARROW_EXPR@0..42 PARAMETER_LIST@0..2 L_PAREN@0..1 "(" @@ -9,22 +9,22 @@ JS_MODULE@0..43 WHITESPACE@2..3 " " FAT_ARROW@3..5 "=>" WHITESPACE@5..6 " " - BLOCK_STMT@6..42 + JS_BLOCK_STATEMENT@6..42 L_CURLY@6..7 "{" WHITESPACE@7..10 "\n " LIST@10..40 - RETURN_STMT@10..17 + JS_RETURN_STATEMENT@10..17 RETURN_KW@10..16 "return" SEMICOLON@16..17 ";" WHITESPACE@17..20 "\n " - RETURN_STMT@20..31 + JS_RETURN_STATEMENT@20..31 RETURN_KW@20..26 "return" WHITESPACE@26..27 " " NAME_REF@27..30 IDENT@27..30 "foo" SEMICOLON@30..31 ";" WHITESPACE@31..34 "\n " - RETURN_STMT@34..40 + JS_RETURN_STATEMENT@34..40 RETURN_KW@34..40 "return" WHITESPACE@40..41 "\n" R_CURLY@41..42 "}" diff --git a/crates/rslint_parser/test_data/inline/ok/semicolons.rast b/crates/rslint_parser/test_data/inline/ok/semicolons.rast index 23ab15810b2..558fcc7635f 100644 --- a/crates/rslint_parser/test_data/inline/ok/semicolons.rast +++ b/crates/rslint_parser/test_data/inline/ok/semicolons.rast @@ -68,11 +68,11 @@ JS_MODULE@0..84 LIST@66..66 R_PAREN@66..67 ")" WHITESPACE@67..68 " " - BLOCK_STMT@68..83 + JS_BLOCK_STATEMENT@68..83 L_CURLY@68..69 "{" WHITESPACE@69..70 " " LIST@70..81 - RETURN_STMT@70..81 + JS_RETURN_STATEMENT@70..81 RETURN_KW@70..76 "return" WHITESPACE@76..77 " " LITERAL@77..81 diff --git a/crates/rslint_parser/test_data/inline/ok/sequence_expr.rast b/crates/rslint_parser/test_data/inline/ok/sequence_expr.rast index 5499de34edd..e1b00c090a8 100644 --- a/crates/rslint_parser/test_data/inline/ok/sequence_expr.rast +++ b/crates/rslint_parser/test_data/inline/ok/sequence_expr.rast @@ -1,6 +1,6 @@ JS_MODULE@0..14 LIST@0..13 - EXPR_STMT@0..13 + JS_EXPRESSION_STATEMENT@0..13 SEQUENCE_EXPR@0..13 LIST@0..13 LITERAL@0..1 diff --git a/crates/rslint_parser/test_data/inline/ok/static_method.rast b/crates/rslint_parser/test_data/inline/ok/static_method.rast index 9394990e45a..5d9fdcb3ad4 100644 --- a/crates/rslint_parser/test_data/inline/ok/static_method.rast +++ b/crates/rslint_parser/test_data/inline/ok/static_method.rast @@ -23,7 +23,7 @@ JS_MODULE@0..99 IDENT@24..27 "bar" R_PAREN@27..28 ")" WHITESPACE@28..29 " " - BLOCK_STMT@29..31 + JS_BLOCK_STATEMENT@29..31 L_CURLY@29..30 "{" LIST@30..30 R_CURLY@30..31 "}" @@ -39,7 +39,7 @@ JS_MODULE@0..99 LIST@45..45 R_PAREN@45..46 ")" WHITESPACE@46..47 " " - BLOCK_STMT@47..49 + JS_BLOCK_STATEMENT@47..49 L_CURLY@47..48 "{" LIST@48..48 R_CURLY@48..49 "}" @@ -56,7 +56,7 @@ JS_MODULE@0..99 LIST@68..68 R_PAREN@68..69 ")" WHITESPACE@69..70 " " - BLOCK_STMT@70..72 + JS_BLOCK_STATEMENT@70..72 L_CURLY@70..71 "{" LIST@71..71 R_CURLY@71..72 "}" @@ -74,7 +74,7 @@ JS_MODULE@0..99 LIST@92..92 R_PAREN@92..93 ")" WHITESPACE@93..94 " " - BLOCK_STMT@94..96 + JS_BLOCK_STATEMENT@94..96 L_CURLY@94..95 "{" LIST@95..95 R_CURLY@95..96 "}" diff --git a/crates/rslint_parser/test_data/inline/ok/subscripts.rast b/crates/rslint_parser/test_data/inline/ok/subscripts.rast index 49c9f0fb50c..094a18441d8 100644 --- a/crates/rslint_parser/test_data/inline/ok/subscripts.rast +++ b/crates/rslint_parser/test_data/inline/ok/subscripts.rast @@ -1,6 +1,6 @@ JS_MODULE@0..33 LIST@0..32 - EXPR_STMT@0..8 + JS_EXPRESSION_STATEMENT@0..8 TEMPLATE@0..8 NAME_REF@0..3 IDENT@0..3 "foo" @@ -9,7 +9,7 @@ JS_MODULE@0..33 TEMPLATE_CHUNK@4..7 "bar" BACKTICK@7..8 "`" WHITESPACE@8..9 "\n" - EXPR_STMT@9..32 + JS_EXPRESSION_STATEMENT@9..32 BRACKET_EXPR@9..32 CALL_EXPR@9..27 CALL_EXPR@9..22 diff --git a/crates/rslint_parser/test_data/inline/ok/this_expr.rast b/crates/rslint_parser/test_data/inline/ok/this_expr.rast index 029fef018f0..ebc96ce2325 100644 --- a/crates/rslint_parser/test_data/inline/ok/this_expr.rast +++ b/crates/rslint_parser/test_data/inline/ok/this_expr.rast @@ -1,10 +1,10 @@ JS_MODULE@0..14 LIST@0..13 - EXPR_STMT@0..4 + JS_EXPRESSION_STATEMENT@0..4 THIS_EXPR@0..4 THIS_KW@0..4 "this" WHITESPACE@4..5 "\n" - EXPR_STMT@5..13 + JS_EXPRESSION_STATEMENT@5..13 DOT_EXPR@5..13 THIS_EXPR@5..9 THIS_KW@5..9 "this" diff --git a/crates/rslint_parser/test_data/inline/ok/try_stmt.rast b/crates/rslint_parser/test_data/inline/ok/try_stmt.rast index db5e9ea2c73..9e016126480 100644 --- a/crates/rslint_parser/test_data/inline/ok/try_stmt.rast +++ b/crates/rslint_parser/test_data/inline/ok/try_stmt.rast @@ -3,7 +3,7 @@ JS_MODULE@0..47 TRY_STMT@0..19 TRY_KW@0..3 "try" WHITESPACE@3..4 " " - BLOCK_STMT@4..6 + JS_BLOCK_STATEMENT@4..6 L_CURLY@4..5 "{" LIST@5..5 R_CURLY@5..6 "}" @@ -17,7 +17,7 @@ JS_MODULE@0..47 IDENT@14..15 "e" R_PAREN@15..16 ")" WHITESPACE@16..17 " " - BLOCK_STMT@17..19 + JS_BLOCK_STATEMENT@17..19 L_CURLY@17..18 "{" LIST@18..18 R_CURLY@18..19 "}" @@ -25,7 +25,7 @@ JS_MODULE@0..47 TRY_STMT@20..46 TRY_KW@20..23 "try" WHITESPACE@23..24 " " - BLOCK_STMT@24..26 + JS_BLOCK_STATEMENT@24..26 L_CURLY@24..25 "{" LIST@25..25 R_CURLY@25..26 "}" @@ -33,7 +33,7 @@ JS_MODULE@0..47 CATCH_CLAUSE@27..35 CATCH_KW@27..32 "catch" WHITESPACE@32..33 " " - BLOCK_STMT@33..35 + JS_BLOCK_STATEMENT@33..35 L_CURLY@33..34 "{" LIST@34..34 R_CURLY@34..35 "}" @@ -41,7 +41,7 @@ JS_MODULE@0..47 FINALIZER@36..46 FINALLY_KW@36..43 "finally" WHITESPACE@43..44 " " - BLOCK_STMT@44..46 + JS_BLOCK_STATEMENT@44..46 L_CURLY@44..45 "{" LIST@45..45 R_CURLY@45..46 "}" diff --git a/crates/rslint_parser/test_data/inline/ok/while_stmt.rast b/crates/rslint_parser/test_data/inline/ok/while_stmt.rast index c48a708d779..a162bdf94c9 100644 --- a/crates/rslint_parser/test_data/inline/ok/while_stmt.rast +++ b/crates/rslint_parser/test_data/inline/ok/while_stmt.rast @@ -9,7 +9,7 @@ JS_MODULE@0..29 TRUE_KW@7..11 "true" R_PAREN@11..12 ")" WHITESPACE@12..13 " " - BLOCK_STMT@13..15 + JS_BLOCK_STATEMENT@13..15 L_CURLY@13..14 "{" LIST@14..14 R_CURLY@14..15 "}" @@ -23,7 +23,7 @@ JS_MODULE@0..29 NUMBER@23..24 "5" R_PAREN@24..25 ")" WHITESPACE@25..26 " " - BLOCK_STMT@26..28 + JS_BLOCK_STATEMENT@26..28 L_CURLY@26..27 "{" LIST@27..27 R_CURLY@27..28 "}" diff --git a/crates/rslint_parser/test_data/inline/ok/with_statement.js b/crates/rslint_parser/test_data/inline/ok/with_statement.js new file mode 100644 index 00000000000..1248565230e --- /dev/null +++ b/crates/rslint_parser/test_data/inline/ok/with_statement.js @@ -0,0 +1,7 @@ +// SCRIPT + +function f(x, o) { + with (o) { + console.log(x); + } +} diff --git a/crates/rslint_parser/test_data/inline/ok/with_statement.rast b/crates/rslint_parser/test_data/inline/ok/with_statement.rast new file mode 100644 index 00000000000..47b6f9bc37e --- /dev/null +++ b/crates/rslint_parser/test_data/inline/ok/with_statement.rast @@ -0,0 +1,58 @@ +JS_SCRIPT@0..65 + COMMENT@0..9 "// SCRIPT" + WHITESPACE@9..11 "\n\n" + LIST@11..64 + FN_DECL@11..64 + FUNCTION_KW@11..19 "function" + WHITESPACE@19..20 " " + NAME@20..21 + IDENT@20..21 "f" + PARAMETER_LIST@21..27 + L_PAREN@21..22 "(" + LIST@22..26 + SINGLE_PATTERN@22..23 + NAME@22..23 + IDENT@22..23 "x" + COMMA@23..24 "," + WHITESPACE@24..25 " " + SINGLE_PATTERN@25..26 + NAME@25..26 + IDENT@25..26 "o" + R_PAREN@26..27 ")" + WHITESPACE@27..28 " " + JS_BLOCK_STATEMENT@28..64 + L_CURLY@28..29 "{" + WHITESPACE@29..31 "\n\t" + LIST@31..62 + JS_WITH_STATEMENT@31..62 + WITH_KW@31..35 "with" + WHITESPACE@35..36 " " + L_PAREN@36..37 "(" + NAME_REF@37..38 + IDENT@37..38 "o" + R_PAREN@38..39 ")" + WHITESPACE@39..40 " " + JS_BLOCK_STATEMENT@40..62 + L_CURLY@40..41 "{" + WHITESPACE@41..44 "\n\t\t" + LIST@44..59 + JS_EXPRESSION_STATEMENT@44..59 + CALL_EXPR@44..58 + DOT_EXPR@44..55 + NAME_REF@44..51 + IDENT@44..51 "console" + DOT@51..52 "." + NAME@52..55 + IDENT@52..55 "log" + ARG_LIST@55..58 + L_PAREN@55..56 "(" + LIST@56..57 + NAME_REF@56..57 + IDENT@56..57 "x" + R_PAREN@57..58 ")" + SEMICOLON@58..59 ";" + WHITESPACE@59..61 "\n\t" + R_CURLY@61..62 "}" + WHITESPACE@62..63 "\n" + R_CURLY@63..64 "}" + WHITESPACE@64..65 "\n" diff --git a/crates/rslint_parser/test_data/inline/ok/yield_expr.rast b/crates/rslint_parser/test_data/inline/ok/yield_expr.rast index 3ca2cbd1ad6..9ec8febd1ca 100644 --- a/crates/rslint_parser/test_data/inline/ok/yield_expr.rast +++ b/crates/rslint_parser/test_data/inline/ok/yield_expr.rast @@ -11,11 +11,11 @@ JS_MODULE@0..45 LIST@14..14 R_PAREN@14..15 ")" WHITESPACE@15..16 " " - BLOCK_STMT@16..44 + JS_BLOCK_STATEMENT@16..44 L_CURLY@16..17 "{" WHITESPACE@17..19 "\n " LIST@19..42 - EXPR_STMT@19..29 + JS_EXPRESSION_STATEMENT@19..29 YIELD_EXPR@19..28 YIELD_KW@19..24 "yield" WHITESPACE@24..25 " " @@ -23,7 +23,7 @@ JS_MODULE@0..45 IDENT@25..28 "foo" SEMICOLON@28..29 ";" WHITESPACE@29..31 "\n " - EXPR_STMT@31..42 + JS_EXPRESSION_STATEMENT@31..42 YIELD_EXPR@31..41 YIELD_KW@31..36 "yield" STAR@36..37 "*" diff --git a/crates/rslint_syntax/src/generated.rs b/crates/rslint_syntax/src/generated.rs index 960d401ce67..8e81380b748 100644 --- a/crates/rslint_syntax/src/generated.rs +++ b/crates/rslint_syntax/src/generated.rs @@ -157,16 +157,17 @@ pub enum SyntaxKind { WHITESPACE, COMMENT, JS_SHEBANG, + JS_IDENTIFIER, JS_SCRIPT, JS_MODULE, JS_DIRECTIVE, ERROR, - BLOCK_STMT, + JS_BLOCK_STATEMENT, VAR_DECL, DECLARATOR, - EMPTY_STMT, + JS_EMPTY_STATEMENT, EXPR, - EXPR_STMT, + JS_EXPRESSION_STATEMENT, IF_STMT, DO_WHILE_STMT, WHILE_STMT, @@ -174,17 +175,17 @@ pub enum SyntaxKind { FOR_IN_STMT, CONTINUE_STMT, BREAK_STMT, - RETURN_STMT, - WITH_STMT, + JS_RETURN_STATEMENT, + JS_WITH_STATEMENT, SWITCH_STMT, CASE_CLAUSE, DEFAULT_CLAUSE, - LABELLED_STMT, + JS_LABELED_STATEMENT, THROW_STMT, TRY_STMT, CATCH_CLAUSE, FINALIZER, - DEBUGGER_STMT, + JS_DEBUGGER_STATEMENT, FN_DECL, NAME, NAME_REF, diff --git a/xtask/js.ungram b/xtask/js.ungram index 104a94089c3..1d274ddd2b6 100644 --- a/xtask/js.ungram +++ b/xtask/js.ungram @@ -63,9 +63,9 @@ JsModule = /////////////// JsAnyStatement = - BlockStmt - | EmptyStmt - | ExprStmt + JsBlockStatement + | JsEmptyStatement + | JsExpressionStatement | IfStmt | DoWhileStmt | WhileStmt @@ -74,13 +74,13 @@ JsAnyStatement = | ForOfStmt | ContinueStmt | BreakStmt - | ReturnStmt - | WithStmt - | LabelledStmt + | JsReturnStatement + | JsWithStatement + | JsLabeledStatement | SwitchStmt | ThrowStmt | TryStmt - | DebuggerStmt + | JsDebuggerStatement | Decl | ImportDecl | ExportNamed @@ -94,16 +94,17 @@ JsAnyStatement = | JsUnknownStatement -// Block statement -BlockStmt = '{' stmts: JsAnyStatement* '}' - +JsBlockStatement = + '{' + statements: JsAnyStatement* + '}' -// Empty statemnet -EmptyStmt = ';'? +JsEmptyStatement = + ';' -// Expression statement -ExprStmt = expr: JsAnyExpression +JsExpressionStatement = + expression: JsAnyExpression ';'? // while statement @@ -150,14 +151,21 @@ ContinueStmt = 'continue' name_ref: NameRef ';'? BreakStmt = 'break' 'ident'? ';' -// return statement -ReturnStmt = 'return' value:JsAnyExpression ';'? +JsReturnStatement = + 'return' + argument: JsAnyExpression? + ';'? + + +JsWithStatement = + 'with' '(' object: JsAnyExpression ')' + body: JsAnyStatement + -// with statement -WithStmt = 'with' condition:Condition cons:JsAnyStatement +JsLabeledStatement = + label: 'ident' ':' + body: JsAnyStatement -// labelled statement -LabelledStmt = label:Name ':' stmt: JsAnyStatement // switch statement SwitchStmt = @@ -178,15 +186,16 @@ ThrowStmt = 'throw' exception:JsAnyExpression ';' // try..catch..finally statement -TryStmt = 'try' test:BlockStmt handler:CatchClause? finalizer:Finalizer? +TryStmt = 'try' test:JsBlockStatement handler:CatchClause? finalizer:Finalizer? // TODO: fix it, the pattern is not mandatory anymore -CatchClause = 'catch' '(' error:Pattern ')' cons:BlockStmt -Finalizer = 'finally' cons:BlockStmt +CatchClause = 'catch' '(' error:Pattern ')' cons:JsBlockStatement +Finalizer = 'finally' cons:JsBlockStatement // debugger statement -DebuggerStmt = 'debugger' ';'? +JsDebuggerStatement = + 'debugger' ';'? /////////////// @@ -277,7 +286,7 @@ FnExpr = parameters:ArgList ':'? return_type:TsType? - body:BlockStmt + body:JsBlockStatement // Arrow expression ArrowExpr = @@ -310,7 +319,7 @@ ClassBody = '{' elements:ClassElement* '}' ClassElement = - EmptyStmt + JsEmptyStatement | Method // probably PrivateProp is not needed | PrivateProp @@ -326,7 +335,7 @@ Constructor = name:PropName type_params:TsTypeParams? parameters:ParameterList - body:BlockStmt + body:JsBlockStatement ConstructorParameters = @@ -432,7 +441,7 @@ Undefined = 'undefined' ExprOrBlock = JsAnyExpression - | BlockStmt + | JsBlockStatement ParameterList = '(' parameters:(Pattern (',' Pattern)* ','?) ')' ArgList = '(' args:(JsAnyExpression (',' JsAnyExpression)* ','?) ')' @@ -529,9 +538,9 @@ IdentProp = name: Name // MISCELLANEOUS /////////////// -Getter = 'get' key:PropName parameters:ParameterList body:BlockStmt +Getter = 'get' key:PropName parameters:ParameterList body:JsBlockStatement -Setter = 'set' key:PropName parameters:ParameterList body:BlockStmt +Setter = 'set' key:PropName parameters:ParameterList body:JsBlockStatement Method = 'static'? @@ -542,7 +551,7 @@ Method = parameters:ParameterList ':'? return_type:TsType? - body:BlockStmt + body:JsBlockStatement SpreadElement = '...' element:JsAnyExpression @@ -577,7 +586,7 @@ FnDecl = parameters:ParameterList ':'? return_type:TsType? - body:BlockStmt + body:JsBlockStatement VarDecl = ('var' | 'const' | manual__:'let') declared:(Declarator (',' Declarator)*) ';'? diff --git a/xtask/src/codegen/kinds_src.rs b/xtask/src/codegen/kinds_src.rs index dbf530a255b..2339a914da5 100644 --- a/xtask/src/codegen/kinds_src.rs +++ b/xtask/src/codegen/kinds_src.rs @@ -163,18 +163,19 @@ pub const KINDS_SRC: KindsSrc = KindsSrc { "WHITESPACE", "COMMENT", "JS_SHEBANG", + "JS_IDENTIFIER", ], nodes: &[ "JS_SCRIPT", "JS_MODULE", "JS_DIRECTIVE", "ERROR", - "BLOCK_STMT", + "JS_BLOCK_STATEMENT", "VAR_DECL", "DECLARATOR", - "EMPTY_STMT", + "JS_EMPTY_STATEMENT", "EXPR", - "EXPR_STMT", + "JS_EXPRESSION_STATEMENT", "IF_STMT", "DO_WHILE_STMT", "WHILE_STMT", @@ -182,17 +183,17 @@ pub const KINDS_SRC: KindsSrc = KindsSrc { "FOR_IN_STMT", "CONTINUE_STMT", "BREAK_STMT", - "RETURN_STMT", - "WITH_STMT", + "JS_RETURN_STATEMENT", + "JS_WITH_STATEMENT", "SWITCH_STMT", "CASE_CLAUSE", "DEFAULT_CLAUSE", - "LABELLED_STMT", + "JS_LABELED_STATEMENT", "THROW_STMT", "TRY_STMT", "CATCH_CLAUSE", "FINALIZER", - "DEBUGGER_STMT", + "JS_DEBUGGER_STATEMENT", "FN_DECL", "NAME", "NAME_REF",