feat(rome_js_parser): instantiation expressions

crates/rome_js_formatter/src/generated.rs

@@ -2786,6 +2786,38 @@ 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::TsInstantiationExpression>
+    for crate::ts::expressions::instantiation_expression::FormatTsInstantiationExpression
+{
+    type Context = JsFormatContext;
+    #[inline(always)]
+    fn fmt(
+        &self,
+        node: &rome_js_syntax::TsInstantiationExpression,
+        f: &mut JsFormatter,
+    ) -> FormatResult<()> {
+        FormatNodeRule::<rome_js_syntax::TsInstantiationExpression>::fmt(self, node, f)
+    }
+}
+impl<'a> AsFormat<'a> for rome_js_syntax::TsInstantiationExpression {
+    type Format = FormatRefWithRule<
+        'a,
+        rome_js_syntax::TsInstantiationExpression,
+        crate::ts::expressions::instantiation_expression::FormatTsInstantiationExpression,
+    >;
+    fn format(&'a self) -> Self::Format {
+        FormatRefWithRule :: new (self , crate :: ts :: expressions :: instantiation_expression :: FormatTsInstantiationExpression :: default ())
+    }
+}
+impl IntoFormat<crate::JsFormatContext> for rome_js_syntax::TsInstantiationExpression {
+    type Format = FormatOwnedWithRule<
+        rome_js_syntax::TsInstantiationExpression,
+        crate::ts::expressions::instantiation_expression::FormatTsInstantiationExpression,
+    >;
+    fn into_format(self) -> Self::Format {
+        FormatOwnedWithRule :: new (self , crate :: ts :: expressions :: instantiation_expression :: FormatTsInstantiationExpression :: default ())
+    }
+}
 impl FormatRule<rome_js_syntax::JsxTagExpression>
     for crate::jsx::expressions::tag_expression::FormatJsxTagExpression
 {

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

@@ -42,6 +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::TsInstantiationExpression(node) => node.format().fmt(f),
             JsAnyExpression::JsxTagExpression(node) => node.format().fmt(f),
         }
     }

crates/rome_js_formatter/src/parentheses.rs

@@ -158,6 +158,7 @@ impl NeedsParentheses for JsAnyExpression {
             JsAnyExpression::TsTypeAssertionExpression(type_assertion) => {
                 type_assertion.needs_parentheses()
             }
+            JsAnyExpression::TsInstantiationExpression(arguments) => arguments.needs_parentheses(),
         }
     }
 
@@ -252,6 +253,9 @@ impl NeedsParentheses for JsAnyExpression {
             JsAnyExpression::TsTypeAssertionExpression(type_assertion) => {
                 type_assertion.needs_parentheses_with_parent(parent)
             }
+            JsAnyExpression::TsInstantiationExpression(expr) => {
+                expr.needs_parentheses_with_parent(parent)
+            }
         }
     }
 }

crates/rome_js_formatter/src/ts/expressions/instantiation_expression.rs

@@ -0,0 +1,28 @@
+use crate::{
+    parentheses::{unary_like_expression_needs_parentheses, NeedsParentheses},
+    prelude::*,
+};
+use rome_formatter::write;
+use rome_js_syntax::{TsInstantiationExpression, TsInstantiationExpressionFields};
+#[derive(Debug, Clone, Default)]
+pub struct FormatTsInstantiationExpression;
+impl FormatNodeRule<TsInstantiationExpression> for FormatTsInstantiationExpression {
+    fn fmt_fields(
+        &self,
+        node: &TsInstantiationExpression,
+        f: &mut JsFormatter,
+    ) -> FormatResult<()> {
+        let TsInstantiationExpressionFields {
+            expression,
+            arguments,
+        } = node.as_fields();
+
+        write![f, [expression.format(), arguments.format()]]
+    }
+}
+
+impl NeedsParentheses for TsInstantiationExpression {
+    fn needs_parentheses_with_parent(&self, parent: &rome_js_syntax::JsSyntaxNode) -> bool {
+        unary_like_expression_needs_parentheses(self.syntax(), parent)
+    }
+}

crates/rome_js_formatter/src/ts/expressions/mod.rs

@@ -1,6 +1,7 @@
 //! Generated file, do not edit by hand, see `xtask/codegen`
 
 pub(crate) mod as_expression;
+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_formatter/src/ts/types/typeof_type.rs

@@ -10,13 +10,19 @@ pub struct FormatTsTypeofType;
 impl FormatNodeRule<TsTypeofType> for FormatTsTypeofType {
     fn fmt_fields(&self, node: &TsTypeofType, f: &mut JsFormatter) -> FormatResult<()> {
         let TsTypeofTypeFields {
+            type_arguments,
             typeof_token,
             expression_name,
         } = node.as_fields();
 
         write![
             f,
-            [typeof_token.format(), space(), expression_name.format()]
+            [
+                typeof_token.format(),
+                space(),
+                expression_name.format(),
+                type_arguments.format()
+            ]
         ]
     }