From d2d9e60e3441b6a9f6c57a07ce66c6b946972fe8 Mon Sep 17 00:00:00 2001 From: IWANABETHATGUY Date: Sat, 10 Sep 2022 17:16:55 +0800 Subject: [PATCH] =?UTF-8?q?chore:=20=F0=9F=A4=96=20rename=20ExpressionWith?= =?UTF-8?q?Arguments=20to=20TsInstantiationExpr?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../src/generated/node_factory.rs | 24 +-- .../src/generated/syntax_factory.rs | 52 +++--- crates/rome_js_formatter/src/generated.rs | 24 +-- .../src/js/any/expression.rs | 2 +- crates/rome_js_formatter/src/parentheses.rs | 6 +- ...guments.rs => instantiation_expression.rs} | 12 +- .../src/ts/expressions/mod.rs | 2 +- crates/rome_js_parser/src/syntax/expr.rs | 8 +- .../ok/ts_instantiation_expressions.rast | 48 ++--- crates/rome_js_syntax/src/generated/kind.rs | 2 +- crates/rome_js_syntax/src/generated/macros.rs | 10 +- crates/rome_js_syntax/src/generated/nodes.rs | 176 +++++++++--------- .../rome_js_syntax/src/generated/nodes_mut.rs | 28 +-- xtask/codegen/js.ungram | 5 +- xtask/codegen/src/kinds_src.rs | 2 +- 15 files changed, 199 insertions(+), 202 deletions(-) rename crates/rome_js_formatter/src/ts/expressions/{expression_with_type_arguments.rs => instantiation_expression.rs} (54%) diff --git a/crates/rome_js_factory/src/generated/node_factory.rs b/crates/rome_js_factory/src/generated/node_factory.rs index 0822aef054d..9d617aa2ee9 100644 --- a/crates/rome_js_factory/src/generated/node_factory.rs +++ b/crates/rome_js_factory/src/generated/node_factory.rs @@ -4455,18 +4455,6 @@ pub fn ts_export_declare_clause( ], )) } -pub fn ts_expression_with_type_arguments( - expression: JsAnyExpression, - arguments: TsTypeArguments, -) -> TsExpressionWithTypeArguments { - TsExpressionWithTypeArguments::unwrap_cast(SyntaxNode::new_detached( - JsSyntaxKind::TS_EXPRESSION_WITH_TYPE_ARGUMENTS, - [ - Some(SyntaxElement::Node(expression.into_syntax())), - Some(SyntaxElement::Node(arguments.into_syntax())), - ], - )) -} pub fn ts_extends_clause(extends_token: SyntaxToken, types: TsTypeList) -> TsExtendsClause { TsExtendsClause::unwrap_cast(SyntaxNode::new_detached( JsSyntaxKind::TS_EXTENDS_CLAUSE, @@ -4929,6 +4917,18 @@ pub fn ts_infer_type(infer_token: SyntaxToken, type_parameter: TsTypeParameterNa ], )) } +pub fn ts_instantiation_expression( + expression: JsAnyExpression, + arguments: TsTypeArguments, +) -> TsInstantiationExpression { + TsInstantiationExpression::unwrap_cast(SyntaxNode::new_detached( + JsSyntaxKind::TS_INSTANTIATION_EXPRESSION, + [ + Some(SyntaxElement::Node(expression.into_syntax())), + Some(SyntaxElement::Node(arguments.into_syntax())), + ], + )) +} pub fn ts_interface_declaration( interface_token: SyntaxToken, id: TsIdentifierBinding, diff --git a/crates/rome_js_factory/src/generated/syntax_factory.rs b/crates/rome_js_factory/src/generated/syntax_factory.rs index e990081f41a..e0033f74b61 100644 --- a/crates/rome_js_factory/src/generated/syntax_factory.rs +++ b/crates/rome_js_factory/src/generated/syntax_factory.rs @@ -6883,32 +6883,6 @@ impl SyntaxFactory for JsSyntaxFactory { } slots.into_node(TS_EXPORT_DECLARE_CLAUSE, children) } - TS_EXPRESSION_WITH_TYPE_ARGUMENTS => { - let mut elements = (&children).into_iter(); - let mut slots: RawNodeSlots<2usize> = RawNodeSlots::default(); - let mut current_element = elements.next(); - if let Some(element) = ¤t_element { - if JsAnyExpression::can_cast(element.kind()) { - slots.mark_present(); - current_element = elements.next(); - } - } - slots.next_slot(); - if let Some(element) = ¤t_element { - if TsTypeArguments::can_cast(element.kind()) { - slots.mark_present(); - current_element = elements.next(); - } - } - slots.next_slot(); - if current_element.is_some() { - return RawSyntaxNode::new( - TS_EXPRESSION_WITH_TYPE_ARGUMENTS.to_unknown(), - children.into_iter().map(Some), - ); - } - slots.into_node(TS_EXPRESSION_WITH_TYPE_ARGUMENTS, children) - } TS_EXTENDS_CLAUSE => { let mut elements = (&children).into_iter(); let mut slots: RawNodeSlots<2usize> = RawNodeSlots::default(); @@ -7575,6 +7549,32 @@ impl SyntaxFactory for JsSyntaxFactory { } slots.into_node(TS_INFER_TYPE, children) } + TS_INSTANTIATION_EXPRESSION => { + let mut elements = (&children).into_iter(); + let mut slots: RawNodeSlots<2usize> = RawNodeSlots::default(); + let mut current_element = elements.next(); + if let Some(element) = ¤t_element { + if JsAnyExpression::can_cast(element.kind()) { + slots.mark_present(); + current_element = elements.next(); + } + } + slots.next_slot(); + if let Some(element) = ¤t_element { + if TsTypeArguments::can_cast(element.kind()) { + slots.mark_present(); + current_element = elements.next(); + } + } + slots.next_slot(); + if current_element.is_some() { + return RawSyntaxNode::new( + TS_INSTANTIATION_EXPRESSION.to_unknown(), + children.into_iter().map(Some), + ); + } + slots.into_node(TS_INSTANTIATION_EXPRESSION, children) + } TS_INTERFACE_DECLARATION => { let mut elements = (&children).into_iter(); let mut slots: RawNodeSlots<7usize> = RawNodeSlots::default(); diff --git a/crates/rome_js_formatter/src/generated.rs b/crates/rome_js_formatter/src/generated.rs index a91cc219b7f..46293030ee2 100644 --- a/crates/rome_js_formatter/src/generated.rs +++ b/crates/rome_js_formatter/src/generated.rs @@ -2786,36 +2786,36 @@ impl IntoFormat for rome_js_syntax::TsNonNullAssertionEx FormatOwnedWithRule :: new (self , crate :: ts :: expressions :: non_null_assertion_expression :: FormatTsNonNullAssertionExpression :: default ()) } } -impl FormatRule - for crate::ts::expressions::expression_with_type_arguments::FormatTsExpressionWithTypeArguments +impl FormatRule + for crate::ts::expressions::instantiation_expression::FormatTsInstantiationExpression { type Context = JsFormatContext; #[inline(always)] fn fmt( &self, - node: &rome_js_syntax::TsExpressionWithTypeArguments, + node: &rome_js_syntax::TsInstantiationExpression, f: &mut JsFormatter, ) -> FormatResult<()> { - FormatNodeRule::::fmt(self, node, f) + FormatNodeRule::::fmt(self, node, f) } } -impl<'a> AsFormat<'a> for rome_js_syntax::TsExpressionWithTypeArguments { +impl<'a> AsFormat<'a> for rome_js_syntax::TsInstantiationExpression { type Format = FormatRefWithRule< 'a, - rome_js_syntax::TsExpressionWithTypeArguments, - crate::ts::expressions::expression_with_type_arguments::FormatTsExpressionWithTypeArguments, + rome_js_syntax::TsInstantiationExpression, + crate::ts::expressions::instantiation_expression::FormatTsInstantiationExpression, >; fn format(&'a self) -> Self::Format { - FormatRefWithRule :: new (self , crate :: ts :: expressions :: expression_with_type_arguments :: FormatTsExpressionWithTypeArguments :: default ()) + FormatRefWithRule :: new (self , crate :: ts :: expressions :: instantiation_expression :: FormatTsInstantiationExpression :: default ()) } } -impl IntoFormat for rome_js_syntax::TsExpressionWithTypeArguments { +impl IntoFormat for rome_js_syntax::TsInstantiationExpression { type Format = FormatOwnedWithRule< - rome_js_syntax::TsExpressionWithTypeArguments, - crate::ts::expressions::expression_with_type_arguments::FormatTsExpressionWithTypeArguments, + rome_js_syntax::TsInstantiationExpression, + crate::ts::expressions::instantiation_expression::FormatTsInstantiationExpression, >; fn into_format(self) -> Self::Format { - FormatOwnedWithRule :: new (self , crate :: ts :: expressions :: expression_with_type_arguments :: FormatTsExpressionWithTypeArguments :: default ()) + FormatOwnedWithRule :: new (self , crate :: ts :: expressions :: instantiation_expression :: FormatTsInstantiationExpression :: default ()) } } impl FormatRule diff --git a/crates/rome_js_formatter/src/js/any/expression.rs b/crates/rome_js_formatter/src/js/any/expression.rs index 4d50336fd40..070b3eb0726 100644 --- a/crates/rome_js_formatter/src/js/any/expression.rs +++ b/crates/rome_js_formatter/src/js/any/expression.rs @@ -42,7 +42,7 @@ impl FormatRule for FormatJsAnyExpression { JsAnyExpression::TsTypeAssertionExpression(node) => node.format().fmt(f), JsAnyExpression::TsAsExpression(node) => node.format().fmt(f), JsAnyExpression::TsNonNullAssertionExpression(node) => node.format().fmt(f), - JsAnyExpression::TsExpressionWithTypeArguments(node) => node.format().fmt(f), + JsAnyExpression::TsInstantiationExpression(node) => node.format().fmt(f), JsAnyExpression::JsxTagExpression(node) => node.format().fmt(f), } } diff --git a/crates/rome_js_formatter/src/parentheses.rs b/crates/rome_js_formatter/src/parentheses.rs index 6ea6d68397a..940657259b4 100644 --- a/crates/rome_js_formatter/src/parentheses.rs +++ b/crates/rome_js_formatter/src/parentheses.rs @@ -158,9 +158,7 @@ impl NeedsParentheses for JsAnyExpression { JsAnyExpression::TsTypeAssertionExpression(type_assertion) => { type_assertion.needs_parentheses() } - JsAnyExpression::TsExpressionWithTypeArguments(arguments) => { - arguments.needs_parentheses() - } + JsAnyExpression::TsInstantiationExpression(arguments) => arguments.needs_parentheses(), } } @@ -255,7 +253,7 @@ impl NeedsParentheses for JsAnyExpression { JsAnyExpression::TsTypeAssertionExpression(type_assertion) => { type_assertion.needs_parentheses_with_parent(parent) } - JsAnyExpression::TsExpressionWithTypeArguments(expr) => { + JsAnyExpression::TsInstantiationExpression(expr) => { expr.needs_parentheses_with_parent(parent) } } diff --git a/crates/rome_js_formatter/src/ts/expressions/expression_with_type_arguments.rs b/crates/rome_js_formatter/src/ts/expressions/instantiation_expression.rs similarity index 54% rename from crates/rome_js_formatter/src/ts/expressions/expression_with_type_arguments.rs rename to crates/rome_js_formatter/src/ts/expressions/instantiation_expression.rs index 71be56bfce1..3e196d4c118 100644 --- a/crates/rome_js_formatter/src/ts/expressions/expression_with_type_arguments.rs +++ b/crates/rome_js_formatter/src/ts/expressions/instantiation_expression.rs @@ -1,15 +1,15 @@ use crate::{parentheses::NeedsParentheses, prelude::*}; use rome_formatter::write; -use rome_js_syntax::{TsExpressionWithTypeArguments, TsExpressionWithTypeArgumentsFields}; +use rome_js_syntax::{TsInstantiationExpression, TsInstantiationExpressionFields}; #[derive(Debug, Clone, Default)] -pub struct FormatTsExpressionWithTypeArguments; -impl FormatNodeRule for FormatTsExpressionWithTypeArguments { +pub struct FormatTsInstantiationExpression; +impl FormatNodeRule for FormatTsInstantiationExpression { fn fmt_fields( &self, - node: &TsExpressionWithTypeArguments, + node: &TsInstantiationExpression, f: &mut JsFormatter, ) -> FormatResult<()> { - let TsExpressionWithTypeArgumentsFields { + let TsInstantiationExpressionFields { expression, arguments, } = node.as_fields(); @@ -18,7 +18,7 @@ impl FormatNodeRule for FormatTsExpressionWithTyp } } -impl NeedsParentheses for TsExpressionWithTypeArguments { +impl NeedsParentheses for TsInstantiationExpression { fn needs_parentheses_with_parent(&self, _: &rome_js_syntax::JsSyntaxNode) -> bool { false } diff --git a/crates/rome_js_formatter/src/ts/expressions/mod.rs b/crates/rome_js_formatter/src/ts/expressions/mod.rs index 52a129b8a05..c133f85b250 100644 --- a/crates/rome_js_formatter/src/ts/expressions/mod.rs +++ b/crates/rome_js_formatter/src/ts/expressions/mod.rs @@ -1,7 +1,7 @@ //! Generated file, do not edit by hand, see `xtask/codegen` pub(crate) mod as_expression; -pub(crate) mod expression_with_type_arguments; +pub(crate) mod instantiation_expression; pub(crate) mod name_with_type_arguments; pub(crate) mod non_null_assertion_expression; pub(crate) mod template_chunk_element; diff --git a/crates/rome_js_parser/src/syntax/expr.rs b/crates/rome_js_parser/src/syntax/expr.rs index 791d4c8868c..752001b4546 100644 --- a/crates/rome_js_parser/src/syntax/expr.rs +++ b/crates/rome_js_parser/src/syntax/expr.rs @@ -703,7 +703,7 @@ fn parse_member_expression_rest( // test ts ts_optional_chain_call // (() => {})?.(); let m = match lhs.kind() { - TS_EXPRESSION_WITH_TYPE_ARGUMENTS => lhs.undo_completion(p), + TS_INSTANTIATION_EXPRESSION => lhs.undo_completion(p), _ => lhs.precede(p), }; parse_template_literal(p, m, *in_optional_chain, true) @@ -712,7 +712,7 @@ fn parse_member_expression_rest( // only those two possible token in cur position `parse_ts_type_arguments_in_expression` could possibly return a `Present(_)` if let Present(_) = parse_ts_type_arguments_in_expression(p) { let new_marker = lhs.precede(p); - lhs = new_marker.complete(p, JsSyntaxKind::TS_EXPRESSION_WITH_TYPE_ARGUMENTS); + lhs = new_marker.complete(p, JsSyntaxKind::TS_INSTANTIATION_EXPRESSION); continue; }; break; @@ -768,7 +768,7 @@ fn parse_new_expr(p: &mut Parser, context: ExpressionContext) -> ParsedSyntax { .or_add_diagnostic(p, expected_expression) .map(|expr| parse_member_expression_rest(p, expr, context, false, &mut false)) { - if let TS_EXPRESSION_WITH_TYPE_ARGUMENTS = lhs.kind() { + if let TS_INSTANTIATION_EXPRESSION = lhs.kind() { lhs.undo_completion(p).abandon(p) }; } @@ -1669,7 +1669,7 @@ fn parse_call_expression_rest( // Cloning here is necessary because parsing out the type arguments may rewind in which // case we want to return the `lhs`. let m = match lhs.kind() { - TS_EXPRESSION_WITH_TYPE_ARGUMENTS if !p.at(T![?.]) => lhs.clone().undo_completion(p), + TS_INSTANTIATION_EXPRESSION if !p.at(T![?.]) => lhs.clone().undo_completion(p), _ => lhs.clone().precede(p), }; diff --git a/crates/rome_js_parser/test_data/inline/ok/ts_instantiation_expressions.rast b/crates/rome_js_parser/test_data/inline/ok/ts_instantiation_expressions.rast index af60bf7ded5..7f0e928501a 100644 --- a/crates/rome_js_parser/test_data/inline/ok/ts_instantiation_expressions.rast +++ b/crates/rome_js_parser/test_data/inline/ok/ts_instantiation_expressions.rast @@ -13,7 +13,7 @@ JsModule { variable_annotation: missing (optional), initializer: JsInitializerClause { eq_token: EQ@7..9 "=" [] [Whitespace(" ")], - expression: TsExpressionWithTypeArguments { + expression: TsInstantiationExpression { expression: JsIdentifierExpression { name: JsReferenceIdentifier { value_token: IDENT@9..11 "fx" [] [], @@ -46,7 +46,7 @@ JsModule { variable_annotation: missing (optional), initializer: JsInitializerClause { eq_token: EQ@28..30 "=" [] [Whitespace(" ")], - expression: TsExpressionWithTypeArguments { + expression: TsInstantiationExpression { expression: JsIdentifierExpression { name: JsReferenceIdentifier { value_token: IDENT@30..32 "fx" [] [], @@ -83,7 +83,7 @@ JsModule { variable_annotation: missing (optional), initializer: JsInitializerClause { eq_token: EQ@57..59 "=" [] [Whitespace(" ")], - expression: TsExpressionWithTypeArguments { + expression: TsInstantiationExpression { expression: JsComputedMemberExpression { object: JsIdentifierExpression { name: JsReferenceIdentifier { @@ -124,7 +124,7 @@ JsModule { variable_annotation: missing (optional), initializer: JsInitializerClause { eq_token: EQ@88..90 "=" [] [Whitespace(" ")], - expression: TsExpressionWithTypeArguments { + expression: TsInstantiationExpression { expression: JsStaticMemberExpression { object: JsIdentifierExpression { name: JsReferenceIdentifier { @@ -164,7 +164,7 @@ JsModule { initializer: JsInitializerClause { eq_token: EQ@129..131 "=" [] [Whitespace(" ")], expression: JsStaticMemberExpression { - object: TsExpressionWithTypeArguments { + object: TsInstantiationExpression { expression: JsIdentifierExpression { name: JsReferenceIdentifier { value_token: IDENT@131..132 "f" [] [], @@ -202,9 +202,9 @@ JsModule { variable_annotation: missing (optional), initializer: JsInitializerClause { eq_token: EQ@168..170 "=" [] [Whitespace(" ")], - expression: TsExpressionWithTypeArguments { + expression: TsInstantiationExpression { expression: JsStaticMemberExpression { - object: TsExpressionWithTypeArguments { + object: TsInstantiationExpression { expression: JsIdentifierExpression { name: JsReferenceIdentifier { value_token: IDENT@170..171 "f" [] [], @@ -252,7 +252,7 @@ JsModule { variable_annotation: missing (optional), initializer: JsInitializerClause { eq_token: EQ@217..219 "=" [] [Whitespace(" ")], - expression: TsExpressionWithTypeArguments { + expression: TsInstantiationExpression { expression: JsComputedMemberExpression { object: JsIdentifierExpression { name: JsReferenceIdentifier { @@ -296,7 +296,7 @@ JsModule { expression: JsComputedMemberExpression { object: JsParenthesizedExpression { l_paren_token: L_PAREN@263..264 "(" [] [], - expression: TsExpressionWithTypeArguments { + expression: TsInstantiationExpression { expression: JsIdentifierExpression { name: JsReferenceIdentifier { value_token: IDENT@264..265 "f" [] [], @@ -420,7 +420,7 @@ JsModule { initializer: JsInitializerClause { eq_token: EQ@358..360 "=" [] [Whitespace(" ")], expression: JsCallExpression { - callee: TsExpressionWithTypeArguments { + callee: TsInstantiationExpression { expression: JsIdentifierExpression { name: JsReferenceIdentifier { value_token: IDENT@360..361 "f" [] [], @@ -462,7 +462,7 @@ JsModule { initializer: JsInitializerClause { eq_token: EQ@384..386 "=" [] [Whitespace(" ")], expression: JsCallExpression { - callee: TsExpressionWithTypeArguments { + callee: TsInstantiationExpression { expression: JsIdentifierExpression { name: JsReferenceIdentifier { value_token: IDENT@386..387 "f" [] [], @@ -588,7 +588,7 @@ JsModule { variable_annotation: missing (optional), initializer: JsInitializerClause { eq_token: EQ@586..588 "=" [] [Whitespace(" ")], - expression: TsExpressionWithTypeArguments { + expression: TsInstantiationExpression { expression: JsIdentifierExpression { name: JsReferenceIdentifier { value_token: IDENT@588..589 "f" [] [], @@ -634,7 +634,7 @@ JsModule { 1: (empty) 2: JS_INITIALIZER_CLAUSE@7..19 0: EQ@7..9 "=" [] [Whitespace(" ")] - 1: TS_EXPRESSION_WITH_TYPE_ARGUMENTS@9..19 + 1: TS_INSTANTIATION_EXPRESSION@9..19 0: JS_IDENTIFIER_EXPRESSION@9..11 0: JS_REFERENCE_IDENTIFIER@9..11 0: IDENT@9..11 "fx" [] [] @@ -655,7 +655,7 @@ JsModule { 1: (empty) 2: JS_INITIALIZER_CLAUSE@28..48 0: EQ@28..30 "=" [] [Whitespace(" ")] - 1: TS_EXPRESSION_WITH_TYPE_ARGUMENTS@30..48 + 1: TS_INSTANTIATION_EXPRESSION@30..48 0: JS_IDENTIFIER_EXPRESSION@30..32 0: JS_REFERENCE_IDENTIFIER@30..32 0: IDENT@30..32 "fx" [] [] @@ -679,7 +679,7 @@ JsModule { 1: (empty) 2: JS_INITIALIZER_CLAUSE@57..77 0: EQ@57..59 "=" [] [Whitespace(" ")] - 1: TS_EXPRESSION_WITH_TYPE_ARGUMENTS@59..77 + 1: TS_INSTANTIATION_EXPRESSION@59..77 0: JS_COMPUTED_MEMBER_EXPRESSION@59..69 0: JS_IDENTIFIER_EXPRESSION@59..61 0: JS_REFERENCE_IDENTIFIER@59..61 @@ -706,7 +706,7 @@ JsModule { 1: (empty) 2: JS_INITIALIZER_CLAUSE@88..101 0: EQ@88..90 "=" [] [Whitespace(" ")] - 1: TS_EXPRESSION_WITH_TYPE_ARGUMENTS@90..101 + 1: TS_INSTANTIATION_EXPRESSION@90..101 0: JS_STATIC_MEMBER_EXPRESSION@90..93 0: JS_IDENTIFIER_EXPRESSION@90..91 0: JS_REFERENCE_IDENTIFIER@90..91 @@ -732,7 +732,7 @@ JsModule { 2: JS_INITIALIZER_CLAUSE@129..142 0: EQ@129..131 "=" [] [Whitespace(" ")] 1: JS_STATIC_MEMBER_EXPRESSION@131..142 - 0: TS_EXPRESSION_WITH_TYPE_ARGUMENTS@131..140 + 0: TS_INSTANTIATION_EXPRESSION@131..140 0: JS_IDENTIFIER_EXPRESSION@131..132 0: JS_REFERENCE_IDENTIFIER@131..132 0: IDENT@131..132 "f" [] [] @@ -756,9 +756,9 @@ JsModule { 1: (empty) 2: JS_INITIALIZER_CLAUSE@168..189 0: EQ@168..170 "=" [] [Whitespace(" ")] - 1: TS_EXPRESSION_WITH_TYPE_ARGUMENTS@170..189 + 1: TS_INSTANTIATION_EXPRESSION@170..189 0: JS_STATIC_MEMBER_EXPRESSION@170..181 - 0: TS_EXPRESSION_WITH_TYPE_ARGUMENTS@170..179 + 0: TS_INSTANTIATION_EXPRESSION@170..179 0: JS_IDENTIFIER_EXPRESSION@170..171 0: JS_REFERENCE_IDENTIFIER@170..171 0: IDENT@170..171 "f" [] [] @@ -788,7 +788,7 @@ JsModule { 1: (empty) 2: JS_INITIALIZER_CLAUSE@217..233 0: EQ@217..219 "=" [] [Whitespace(" ")] - 1: TS_EXPRESSION_WITH_TYPE_ARGUMENTS@219..233 + 1: TS_INSTANTIATION_EXPRESSION@219..233 0: JS_COMPUTED_MEMBER_EXPRESSION@219..225 0: JS_IDENTIFIER_EXPRESSION@219..220 0: JS_REFERENCE_IDENTIFIER@219..220 @@ -818,7 +818,7 @@ JsModule { 1: JS_COMPUTED_MEMBER_EXPRESSION@263..279 0: JS_PARENTHESIZED_EXPRESSION@263..274 0: L_PAREN@263..264 "(" [] [] - 1: TS_EXPRESSION_WITH_TYPE_ARGUMENTS@264..273 + 1: TS_INSTANTIATION_EXPRESSION@264..273 0: JS_IDENTIFIER_EXPRESSION@264..265 0: JS_REFERENCE_IDENTIFIER@264..265 0: IDENT@264..265 "f" [] [] @@ -899,7 +899,7 @@ JsModule { 2: JS_INITIALIZER_CLAUSE@358..373 0: EQ@358..360 "=" [] [Whitespace(" ")] 1: JS_CALL_EXPRESSION@360..373 - 0: TS_EXPRESSION_WITH_TYPE_ARGUMENTS@360..369 + 0: TS_INSTANTIATION_EXPRESSION@360..369 0: JS_IDENTIFIER_EXPRESSION@360..361 0: JS_REFERENCE_IDENTIFIER@360..361 0: IDENT@360..361 "f" [] [] @@ -927,7 +927,7 @@ JsModule { 2: JS_INITIALIZER_CLAUSE@384..407 0: EQ@384..386 "=" [] [Whitespace(" ")] 1: JS_CALL_EXPRESSION@386..407 - 0: TS_EXPRESSION_WITH_TYPE_ARGUMENTS@386..395 + 0: TS_INSTANTIATION_EXPRESSION@386..395 0: JS_IDENTIFIER_EXPRESSION@386..387 0: JS_REFERENCE_IDENTIFIER@386..387 0: IDENT@386..387 "f" [] [] @@ -1009,7 +1009,7 @@ JsModule { 1: (empty) 2: JS_INITIALIZER_CLAUSE@586..595 0: EQ@586..588 "=" [] [Whitespace(" ")] - 1: TS_EXPRESSION_WITH_TYPE_ARGUMENTS@588..595 + 1: TS_INSTANTIATION_EXPRESSION@588..595 0: JS_IDENTIFIER_EXPRESSION@588..589 0: JS_REFERENCE_IDENTIFIER@588..589 0: IDENT@588..589 "f" [] [] diff --git a/crates/rome_js_syntax/src/generated/kind.rs b/crates/rome_js_syntax/src/generated/kind.rs index ed3fa3f92e1..2a8d161dcbd 100644 --- a/crates/rome_js_syntax/src/generated/kind.rs +++ b/crates/rome_js_syntax/src/generated/kind.rs @@ -441,7 +441,7 @@ pub enum JsSyntaxKind { TS_NON_NULL_ASSERTION_EXPRESSION, TS_TYPE_ASSERTION_EXPRESSION, TS_AS_EXPRESSION, - TS_EXPRESSION_WITH_TYPE_ARGUMENTS, + TS_INSTANTIATION_EXPRESSION, TS_ENUM_DECLARATION, TS_ENUM_MEMBER_LIST, TS_ENUM_MEMBER, diff --git a/crates/rome_js_syntax/src/generated/macros.rs b/crates/rome_js_syntax/src/generated/macros.rs index 9d44e41e85e..dfb34c7c652 100644 --- a/crates/rome_js_syntax/src/generated/macros.rs +++ b/crates/rome_js_syntax/src/generated/macros.rs @@ -848,11 +848,6 @@ macro_rules! map_syntax_node { let $pattern = unsafe { $crate::TsExportDeclareClause::new_unchecked(node) }; $body } - $crate::JsSyntaxKind::TS_EXPRESSION_WITH_TYPE_ARGUMENTS => { - let $pattern = - unsafe { $crate::TsExpressionWithTypeArguments::new_unchecked(node) }; - $body - } $crate::JsSyntaxKind::TS_EXTENDS_CLAUSE => { let $pattern = unsafe { $crate::TsExtendsClause::new_unchecked(node) }; $body @@ -929,6 +924,11 @@ macro_rules! map_syntax_node { let $pattern = unsafe { $crate::TsInferType::new_unchecked(node) }; $body } + $crate::JsSyntaxKind::TS_INSTANTIATION_EXPRESSION => { + let $pattern = + unsafe { $crate::TsInstantiationExpression::new_unchecked(node) }; + $body + } $crate::JsSyntaxKind::TS_INTERFACE_DECLARATION => { let $pattern = unsafe { $crate::TsInterfaceDeclaration::new_unchecked(node) }; $body diff --git a/crates/rome_js_syntax/src/generated/nodes.rs b/crates/rome_js_syntax/src/generated/nodes.rs index 62b42c12526..de017ed048f 100644 --- a/crates/rome_js_syntax/src/generated/nodes.rs +++ b/crates/rome_js_syntax/src/generated/nodes.rs @@ -8601,45 +8601,6 @@ pub struct TsExportDeclareClauseFields { pub declaration: SyntaxResult, } #[derive(Clone, PartialEq, Eq, Hash)] -pub struct TsExpressionWithTypeArguments { - pub(crate) syntax: SyntaxNode, -} -impl TsExpressionWithTypeArguments { - #[doc = r" Create an AstNode from a SyntaxNode without checking its kind"] - #[doc = r""] - #[doc = r" # Safety"] - #[doc = r" This function must be guarded with a call to [AstNode::can_cast]"] - #[doc = r" or a match on [SyntaxNode::kind]"] - #[inline] - pub const unsafe fn new_unchecked(syntax: SyntaxNode) -> Self { Self { syntax } } - pub fn as_fields(&self) -> TsExpressionWithTypeArgumentsFields { - TsExpressionWithTypeArgumentsFields { - expression: self.expression(), - arguments: self.arguments(), - } - } - pub fn expression(&self) -> SyntaxResult { - support::required_node(&self.syntax, 0usize) - } - pub fn arguments(&self) -> SyntaxResult { - support::required_node(&self.syntax, 1usize) - } -} -#[cfg(feature = "serde")] -impl Serialize for TsExpressionWithTypeArguments { - fn serialize(&self, serializer: S) -> Result - where - S: Serializer, - { - self.as_fields().serialize(serializer) - } -} -#[cfg_attr(feature = "serde", derive(Serialize))] -pub struct TsExpressionWithTypeArgumentsFields { - pub expression: SyntaxResult, - pub arguments: SyntaxResult, -} -#[derive(Clone, PartialEq, Eq, Hash)] pub struct TsExtendsClause { pub(crate) syntax: SyntaxNode, } @@ -9431,6 +9392,45 @@ pub struct TsInferTypeFields { pub type_parameter: SyntaxResult, } #[derive(Clone, PartialEq, Eq, Hash)] +pub struct TsInstantiationExpression { + pub(crate) syntax: SyntaxNode, +} +impl TsInstantiationExpression { + #[doc = r" Create an AstNode from a SyntaxNode without checking its kind"] + #[doc = r""] + #[doc = r" # Safety"] + #[doc = r" This function must be guarded with a call to [AstNode::can_cast]"] + #[doc = r" or a match on [SyntaxNode::kind]"] + #[inline] + pub const unsafe fn new_unchecked(syntax: SyntaxNode) -> Self { Self { syntax } } + pub fn as_fields(&self) -> TsInstantiationExpressionFields { + TsInstantiationExpressionFields { + expression: self.expression(), + arguments: self.arguments(), + } + } + pub fn expression(&self) -> SyntaxResult { + support::required_node(&self.syntax, 0usize) + } + pub fn arguments(&self) -> SyntaxResult { + support::required_node(&self.syntax, 1usize) + } +} +#[cfg(feature = "serde")] +impl Serialize for TsInstantiationExpression { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + self.as_fields().serialize(serializer) + } +} +#[cfg_attr(feature = "serde", derive(Serialize))] +pub struct TsInstantiationExpressionFields { + pub expression: SyntaxResult, + pub arguments: SyntaxResult, +} +#[derive(Clone, PartialEq, Eq, Hash)] pub struct TsInterfaceDeclaration { pub(crate) syntax: SyntaxNode, } @@ -12712,7 +12712,7 @@ pub enum JsAnyExpression { JsxTagExpression(JsxTagExpression), NewTarget(NewTarget), TsAsExpression(TsAsExpression), - TsExpressionWithTypeArguments(TsExpressionWithTypeArguments), + TsInstantiationExpression(TsInstantiationExpression), TsNonNullAssertionExpression(TsNonNullAssertionExpression), TsTypeAssertionExpression(TsTypeAssertionExpression), } @@ -12915,9 +12915,9 @@ impl JsAnyExpression { _ => None, } } - pub fn as_ts_expression_with_type_arguments(&self) -> Option<&TsExpressionWithTypeArguments> { + pub fn as_ts_instantiation_expression(&self) -> Option<&TsInstantiationExpression> { match &self { - JsAnyExpression::TsExpressionWithTypeArguments(item) => Some(item), + JsAnyExpression::TsInstantiationExpression(item) => Some(item), _ => None, } } @@ -21741,35 +21741,6 @@ impl From for SyntaxNode { impl From for SyntaxElement { fn from(n: TsExportDeclareClause) -> SyntaxElement { n.syntax.into() } } -impl AstNode for TsExpressionWithTypeArguments { - type Language = Language; - const KIND_SET: SyntaxKindSet = - SyntaxKindSet::from_raw(RawSyntaxKind(TS_EXPRESSION_WITH_TYPE_ARGUMENTS as u16)); - fn can_cast(kind: SyntaxKind) -> bool { kind == TS_EXPRESSION_WITH_TYPE_ARGUMENTS } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { &self.syntax } - fn into_syntax(self) -> SyntaxNode { self.syntax } -} -impl std::fmt::Debug for TsExpressionWithTypeArguments { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - f.debug_struct("TsExpressionWithTypeArguments") - .field("expression", &support::DebugSyntaxResult(self.expression())) - .field("arguments", &support::DebugSyntaxResult(self.arguments())) - .finish() - } -} -impl From for SyntaxNode { - fn from(n: TsExpressionWithTypeArguments) -> SyntaxNode { n.syntax } -} -impl From for SyntaxElement { - fn from(n: TsExpressionWithTypeArguments) -> SyntaxElement { n.syntax.into() } -} impl AstNode for TsExtendsClause { type Language = Language; const KIND_SET: SyntaxKindSet = @@ -22427,6 +22398,35 @@ impl From for SyntaxNode { impl From for SyntaxElement { fn from(n: TsInferType) -> SyntaxElement { n.syntax.into() } } +impl AstNode for TsInstantiationExpression { + type Language = Language; + const KIND_SET: SyntaxKindSet = + SyntaxKindSet::from_raw(RawSyntaxKind(TS_INSTANTIATION_EXPRESSION as u16)); + fn can_cast(kind: SyntaxKind) -> bool { kind == TS_INSTANTIATION_EXPRESSION } + fn cast(syntax: SyntaxNode) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { self.syntax } +} +impl std::fmt::Debug for TsInstantiationExpression { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.debug_struct("TsInstantiationExpression") + .field("expression", &support::DebugSyntaxResult(self.expression())) + .field("arguments", &support::DebugSyntaxResult(self.arguments())) + .finish() + } +} +impl From for SyntaxNode { + fn from(n: TsInstantiationExpression) -> SyntaxNode { n.syntax } +} +impl From for SyntaxElement { + fn from(n: TsInstantiationExpression) -> SyntaxElement { n.syntax.into() } +} impl AstNode for TsInterfaceDeclaration { type Language = Language; const KIND_SET: SyntaxKindSet = @@ -26657,9 +26657,9 @@ impl From for JsAnyExpression { impl From for JsAnyExpression { fn from(node: TsAsExpression) -> JsAnyExpression { JsAnyExpression::TsAsExpression(node) } } -impl From for JsAnyExpression { - fn from(node: TsExpressionWithTypeArguments) -> JsAnyExpression { - JsAnyExpression::TsExpressionWithTypeArguments(node) +impl From for JsAnyExpression { + fn from(node: TsInstantiationExpression) -> JsAnyExpression { + JsAnyExpression::TsInstantiationExpression(node) } } impl From for JsAnyExpression { @@ -26707,7 +26707,7 @@ impl AstNode for JsAnyExpression { .union(JsxTagExpression::KIND_SET) .union(NewTarget::KIND_SET) .union(TsAsExpression::KIND_SET) - .union(TsExpressionWithTypeArguments::KIND_SET) + .union(TsInstantiationExpression::KIND_SET) .union(TsNonNullAssertionExpression::KIND_SET) .union(TsTypeAssertionExpression::KIND_SET); fn can_cast(kind: SyntaxKind) -> bool { @@ -26744,7 +26744,7 @@ impl AstNode for JsAnyExpression { | JSX_TAG_EXPRESSION | NEW_TARGET | TS_AS_EXPRESSION - | TS_EXPRESSION_WITH_TYPE_ARGUMENTS + | TS_INSTANTIATION_EXPRESSION | TS_NON_NULL_ASSERTION_EXPRESSION | TS_TYPE_ASSERTION_EXPRESSION => true, k if JsAnyLiteralExpression::can_cast(k) => true, @@ -26819,10 +26819,8 @@ impl AstNode for JsAnyExpression { JSX_TAG_EXPRESSION => JsAnyExpression::JsxTagExpression(JsxTagExpression { syntax }), NEW_TARGET => JsAnyExpression::NewTarget(NewTarget { syntax }), TS_AS_EXPRESSION => JsAnyExpression::TsAsExpression(TsAsExpression { syntax }), - TS_EXPRESSION_WITH_TYPE_ARGUMENTS => { - JsAnyExpression::TsExpressionWithTypeArguments(TsExpressionWithTypeArguments { - syntax, - }) + TS_INSTANTIATION_EXPRESSION => { + JsAnyExpression::TsInstantiationExpression(TsInstantiationExpression { syntax }) } TS_NON_NULL_ASSERTION_EXPRESSION => { JsAnyExpression::TsNonNullAssertionExpression(TsNonNullAssertionExpression { @@ -26877,7 +26875,7 @@ impl AstNode for JsAnyExpression { JsAnyExpression::JsxTagExpression(it) => &it.syntax, JsAnyExpression::NewTarget(it) => &it.syntax, JsAnyExpression::TsAsExpression(it) => &it.syntax, - JsAnyExpression::TsExpressionWithTypeArguments(it) => &it.syntax, + JsAnyExpression::TsInstantiationExpression(it) => &it.syntax, JsAnyExpression::TsNonNullAssertionExpression(it) => &it.syntax, JsAnyExpression::TsTypeAssertionExpression(it) => &it.syntax, JsAnyExpression::JsAnyLiteralExpression(it) => it.syntax(), @@ -26917,7 +26915,7 @@ impl AstNode for JsAnyExpression { JsAnyExpression::JsxTagExpression(it) => it.syntax, JsAnyExpression::NewTarget(it) => it.syntax, JsAnyExpression::TsAsExpression(it) => it.syntax, - JsAnyExpression::TsExpressionWithTypeArguments(it) => it.syntax, + JsAnyExpression::TsInstantiationExpression(it) => it.syntax, JsAnyExpression::TsNonNullAssertionExpression(it) => it.syntax, JsAnyExpression::TsTypeAssertionExpression(it) => it.syntax, JsAnyExpression::JsAnyLiteralExpression(it) => it.into_syntax(), @@ -26960,7 +26958,7 @@ impl std::fmt::Debug for JsAnyExpression { JsAnyExpression::JsxTagExpression(it) => std::fmt::Debug::fmt(it, f), JsAnyExpression::NewTarget(it) => std::fmt::Debug::fmt(it, f), JsAnyExpression::TsAsExpression(it) => std::fmt::Debug::fmt(it, f), - JsAnyExpression::TsExpressionWithTypeArguments(it) => std::fmt::Debug::fmt(it, f), + JsAnyExpression::TsInstantiationExpression(it) => std::fmt::Debug::fmt(it, f), JsAnyExpression::TsNonNullAssertionExpression(it) => std::fmt::Debug::fmt(it, f), JsAnyExpression::TsTypeAssertionExpression(it) => std::fmt::Debug::fmt(it, f), } @@ -27002,7 +27000,7 @@ impl From for SyntaxNode { JsAnyExpression::JsxTagExpression(it) => it.into(), JsAnyExpression::NewTarget(it) => it.into(), JsAnyExpression::TsAsExpression(it) => it.into(), - JsAnyExpression::TsExpressionWithTypeArguments(it) => it.into(), + JsAnyExpression::TsInstantiationExpression(it) => it.into(), JsAnyExpression::TsNonNullAssertionExpression(it) => it.into(), JsAnyExpression::TsTypeAssertionExpression(it) => it.into(), } @@ -32908,11 +32906,6 @@ impl std::fmt::Display for TsExportDeclareClause { std::fmt::Display::fmt(self.syntax(), f) } } -impl std::fmt::Display for TsExpressionWithTypeArguments { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} impl std::fmt::Display for TsExtendsClause { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { std::fmt::Display::fmt(self.syntax(), f) @@ -32998,6 +32991,11 @@ impl std::fmt::Display for TsInferType { std::fmt::Display::fmt(self.syntax(), f) } } +impl std::fmt::Display for TsInstantiationExpression { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + std::fmt::Display::fmt(self.syntax(), f) + } +} impl std::fmt::Display for TsInterfaceDeclaration { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { std::fmt::Display::fmt(self.syntax(), f) diff --git a/crates/rome_js_syntax/src/generated/nodes_mut.rs b/crates/rome_js_syntax/src/generated/nodes_mut.rs index d43baa3620d..ea730d2c4ee 100644 --- a/crates/rome_js_syntax/src/generated/nodes_mut.rs +++ b/crates/rome_js_syntax/src/generated/nodes_mut.rs @@ -4212,20 +4212,6 @@ impl TsExportDeclareClause { ) } } -impl TsExpressionWithTypeArguments { - pub fn with_expression(self, element: JsAnyExpression) -> Self { - Self::unwrap_cast( - self.syntax - .splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))), - ) - } - pub fn with_arguments(self, element: TsTypeArguments) -> Self { - Self::unwrap_cast( - self.syntax - .splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))), - ) - } -} impl TsExtendsClause { pub fn with_extends_token(self, element: SyntaxToken) -> Self { Self::unwrap_cast( @@ -4656,6 +4642,20 @@ impl TsInferType { ) } } +impl TsInstantiationExpression { + pub fn with_expression(self, element: JsAnyExpression) -> Self { + Self::unwrap_cast( + self.syntax + .splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))), + ) + } + pub fn with_arguments(self, element: TsTypeArguments) -> Self { + Self::unwrap_cast( + self.syntax + .splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))), + ) + } +} impl TsInterfaceDeclaration { pub fn with_interface_token(self, element: SyntaxToken) -> Self { Self::unwrap_cast( diff --git a/xtask/codegen/js.ungram b/xtask/codegen/js.ungram index bb64c1afae1..412a7d23c4f 100644 --- a/xtask/codegen/js.ungram +++ b/xtask/codegen/js.ungram @@ -316,7 +316,7 @@ JsAnyExpression = | TsTypeAssertionExpression | TsAsExpression | TsNonNullAssertionExpression - | TsExpressionWithTypeArguments + | TsInstantiationExpression // JSX | JsxTagExpression @@ -2111,7 +2111,8 @@ TsTypeAssertionExpression = '>' expression: JsAnyExpression -TsExpressionWithTypeArguments = +// This `SyntaxKind` is related to `ExpressionWithTypeArguments` in Typescript +TsInstantiationExpression = expression: JsAnyExpression arguments: TsTypeArguments diff --git a/xtask/codegen/src/kinds_src.rs b/xtask/codegen/src/kinds_src.rs index 6a54077a537..c29e4578b0f 100644 --- a/xtask/codegen/src/kinds_src.rs +++ b/xtask/codegen/src/kinds_src.rs @@ -461,7 +461,7 @@ pub const JS_KINDS_SRC: KindsSrc = KindsSrc { "TS_NON_NULL_ASSERTION_EXPRESSION", "TS_TYPE_ASSERTION_EXPRESSION", "TS_AS_EXPRESSION", - "TS_EXPRESSION_WITH_TYPE_ARGUMENTS", + "TS_INSTANTIATION_EXPRESSION", "TS_ENUM_DECLARATION", "TS_ENUM_MEMBER_LIST", "TS_ENUM_MEMBER",