chore: 🤖 rename ExpressionWithArguments to TsInstantiationExpr

crates/rome_js_formatter/src/generated.rs

@@ -2786,36 +2786,36 @@ impl IntoFormat<crate::JsFormatContext> for rome_js_syntax::TsNonNullAssertionEx
         FormatOwnedWithRule :: new (self , crate :: ts :: expressions :: non_null_assertion_expression :: FormatTsNonNullAssertionExpression :: default ())
     }
 }
-impl FormatRule<rome_js_syntax::TsExpressionWithTypeArguments>
-    for crate::ts::expressions::expression_with_type_arguments::FormatTsExpressionWithTypeArguments
+impl FormatRule<rome_js_syntax::TsInstantiationExpression>
+    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::<rome_js_syntax::TsExpressionWithTypeArguments>::fmt(self, node, f)
+        FormatNodeRule::<rome_js_syntax::TsInstantiationExpression>::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<crate::JsFormatContext> for rome_js_syntax::TsExpressionWithTypeArguments {
+impl IntoFormat<crate::JsFormatContext> 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<rome_js_syntax::JsxTagExpression>

crates/rome_js_formatter/src/js/any/expression.rs

@@ -42,7 +42,7 @@ impl FormatRule<JsAnyExpression> 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),
         }
     }

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)
             }
         }

crates/rome_js_formatter/src/ts/expressions/expression_with_type_arguments.rs → 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<TsExpressionWithTypeArguments> for FormatTsExpressionWithTypeArguments {
+pub struct FormatTsInstantiationExpression;
+impl FormatNodeRule<TsInstantiationExpression> 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<TsExpressionWithTypeArguments> for FormatTsExpressionWithTyp
     }
 }
 
-impl NeedsParentheses for TsExpressionWithTypeArguments {
+impl NeedsParentheses for TsInstantiationExpression {
     fn needs_parentheses_with_parent(&self, _: &rome_js_syntax::JsSyntaxNode) -> bool {
         false
     }

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;

crates/rome_js_parser/src/syntax/expr.rs

@@ -703,7 +703,7 @@ fn parse_member_expression_rest(
                 // test ts ts_optional_chain_call
                 // (<A, B>() => {})?.<A, B>();
                 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),
         };