feat(rome_formatter): template literals and static initializers

crates/rome_formatter/src/cst.rs

@@ -9,7 +9,8 @@ use rslint_parser::ast::{
     JsNullLiteralExpression, JsNumberLiteralExpression, JsObjectExpression, JsParameters,
     JsPropertyClassMember, JsPropertyObjectMember, JsReturnStatement, JsScript,
     JsSequenceExpression, JsSetterClassMember, JsShorthandPropertyObjectMember, JsSpread,
-    JsStatementList, JsStringLiteralExpression, JsSwitchStatement, JsTryStatement,
+    JsStatementList, JsStaticInitializationBlockClassMember, JsStringLiteralExpression,
+    JsSwitchStatement, JsTemplate, JsTemplateChunkElement, JsTemplateElement, JsTryStatement,
     JsUnknownAssignment, JsUnknownBinding, JsUnknownExpression, JsUnknownImportAssertionEntry,
     JsUnknownMember, JsUnknownNamedImportSpecifier, JsUnknownParameter, JsUnknownStatement,
     JsVariableDeclaration, JsVariableDeclarations, JsVariableStatement, JsWhileStatement,
@@ -198,6 +199,21 @@ impl ToFormatElement for SyntaxNode {
                     .unwrap()
                     .to_format_element(formatter)
             }
+            JsSyntaxKind::JS_STATIC_INITIALIZATION_BLOCK_CLASS_MEMBER => {
+                JsStaticInitializationBlockClassMember::cast(self.clone())
+                    .unwrap()
+                    .to_format_element(formatter)
+            }
+            JsSyntaxKind::JS_TEMPLATE => JsTemplate::cast(self.clone())
+                .unwrap()
+                .to_format_element(formatter),
+
+            JsSyntaxKind::JS_TEMPLATE_ELEMENT => JsTemplateElement::cast(self.clone())
+                .unwrap()
+                .to_format_element(formatter),
+            JsSyntaxKind::JS_TEMPLATE_CHUNK_ELEMENT => JsTemplateChunkElement::cast(self.clone())
+                .unwrap()
+                .to_format_element(formatter),
 
             JsSyntaxKind::JS_STATEMENT_LIST => Ok(format_statements(
                 JsStatementList::cast(self.clone()).unwrap(),

crates/rome_formatter/src/ts/assignment/array_assignment_pattern.rs

@@ -39,8 +39,8 @@ impl ToFormatElement for JsAnyArrayAssignmentPatternElement {
             JsAnyArrayAssignmentPatternElement::JsArrayHole(array_hole) => {
                 array_hole.to_format_element(formatter)
             }
-            JsAnyArrayAssignmentPatternElement::JsUnknownAssignment(_unknown_assignment) => {
-                todo!()
+            JsAnyArrayAssignmentPatternElement::JsUnknownAssignment(unknown_assignment) => {
+                unknown_assignment.to_format_element(formatter)
             }
         }
     }

crates/rome_formatter/src/ts/class/class_member.rs

@@ -19,7 +19,9 @@ impl ToFormatElement for JsAnyClassMember {
             JsAnyClassMember::JsUnknownMember(unknown_member) => {
                 unknown_member.to_format_element(formatter)
             }
-            JsAnyClassMember::JsStaticInitializationBlockClassMember(_) => todo!(),
+            JsAnyClassMember::JsStaticInitializationBlockClassMember(node) => {
+                node.to_format_element(formatter)
+            }
         }
     }
 }

crates/rome_formatter/src/ts/class/mod.rs

@@ -11,3 +11,4 @@ mod method_class_member;
 mod private_class_member_name;
 mod property_class_member;
 mod setter_class_member;
+mod static_initialization_block_class_member;

crates/rome_formatter/src/ts/class/static_initialization_block_class_member.rs

@@ -0,0 +1,24 @@
+use crate::ts::statements::format_statements;
+use crate::{
+    block_indent, format_elements, space_token, FormatElement, FormatResult, Formatter,
+    ToFormatElement,
+};
+use rslint_parser::ast::JsStaticInitializationBlockClassMember;
+
+impl ToFormatElement for JsStaticInitializationBlockClassMember {
+    fn to_format_element(&self, formatter: &Formatter) -> FormatResult<FormatElement> {
+        let static_token = formatter.format_token(&self.static_token()?)?;
+        let separated = formatter.format_delimited(
+            &self.l_curly_token()?,
+            |open_token_trailing, close_token_leading| {
+                Ok(block_indent(format_elements![
+                    open_token_trailing,
+                    format_statements(self.statements(), formatter),
+                    close_token_leading,
+                ]))
+            },
+            &self.r_curly_token()?,
+        )?;
+        Ok(format_elements![static_token, space_token(), separated])
+    }
+}

crates/rome_formatter/src/ts/expressions/any_template_element.rs

@@ -0,0 +1,11 @@
+use crate::{FormatElement, FormatResult, Formatter, ToFormatElement};
+use rslint_parser::ast::JsAnyTemplateElement;
+
+impl ToFormatElement for JsAnyTemplateElement {
+    fn to_format_element(&self, formatter: &Formatter) -> FormatResult<FormatElement> {
+        match self {
+            JsAnyTemplateElement::JsTemplateChunkElement(node) => node.to_format_element(formatter),
+            JsAnyTemplateElement::JsTemplateElement(node) => node.to_format_element(formatter),
+        }
+    }
+}

crates/rome_formatter/src/ts/expressions/expression.rs

@@ -17,7 +17,7 @@ impl ToFormatElement for JsAnyExpression {
             JsAnyExpression::JsAnyLiteralExpression(literal) => {
                 literal.to_format_element(formatter)
             }
-            JsAnyExpression::Template(_) => todo!(),
+            JsAnyExpression::JsTemplate(node) => node.to_format_element(formatter),
             JsAnyExpression::JsIdentifierExpression(identifier_expr) => {
                 identifier_expr.to_format_element(formatter)
             }

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

@@ -1,3 +1,4 @@
+mod any_template_element;
 mod array_expr;
 mod arrow_expr;
 mod call_expression;
@@ -9,4 +10,7 @@ mod object_expression;
 mod sequence_expression;
 mod static_member_expression;
 mod super_expression;
+mod template;
+mod template_chunk_element;
+mod template_element;
 mod update_expression;

crates/rome_formatter/src/ts/expressions/template.rs

@@ -0,0 +1,23 @@
+use crate::{
+    empty_element, format_elements, FormatElement, FormatResult, Formatter, ToFormatElement,
+};
+use rslint_parser::ast::JsTemplate;
+
+impl ToFormatElement for JsTemplate {
+    fn to_format_element(&self, formatter: &Formatter) -> FormatResult<FormatElement> {
+        let tag = if let Some(tag) = self.tag() {
+            formatter.format_node(&tag)?
+        } else {
+            empty_element()
+        };
+        let l_tick = formatter.format_token(&self.l_tick_token()?)?;
+        let r_tick = formatter.format_token(&self.r_tick_token()?)?;
+
+        Ok(format_elements![
+            tag,
+            l_tick,
+            concat_elements(formatter.format_nodes(self.elements())?),
+            r_tick
+        ])
+    }
+}

crates/rome_formatter/src/ts/expressions/template_chunk_element.rs

@@ -0,0 +1,8 @@
+use crate::{FormatElement, FormatResult, Formatter, ToFormatElement};
+use rslint_parser::ast::JsTemplateChunkElement;
+
+impl ToFormatElement for JsTemplateChunkElement {
+    fn to_format_element(&self, formatter: &Formatter) -> FormatResult<FormatElement> {
+        formatter.format_token(&self.template_chunk_token()?)
+    }
+}

crates/rome_formatter/src/ts/expressions/template_element.rs

@@ -0,0 +1,11 @@
+use crate::{format_elements, FormatElement, FormatResult, Formatter, ToFormatElement};
+use rslint_parser::ast::JsTemplateElement;
+
+impl ToFormatElement for JsTemplateElement {
+    fn to_format_element(&self, formatter: &Formatter) -> FormatResult<FormatElement> {
+        let dollar_curly = formatter.format_token(&self.dollar_curly_token()?)?;
+        let expression = formatter.format_node(&self.expression()?)?;
+        let r_curly = formatter.format_token(&self.r_curly_token()?)?;
+        Ok(format_elements![dollar_curly, expression, r_curly])
+    }
+}

crates/rome_formatter/src/ts/mod.rs

@@ -12,7 +12,6 @@ mod object_members;
 mod parameter_list;
 mod root;
 mod statements;
-mod template;
 mod unknown;
 
 pub(crate) use statements::format_statements;

crates/rome_formatter/tests/specs/js/module/class/class.js

@@ -1,4 +1,7 @@
 class Foo extends Boar {
+	static { // some comment
+		this.a = "test";
+	}
 	constructor(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb, c = d) {
 		super();
 	}

crates/rome_formatter/tests/specs/js/module/class/class.js.snap

@@ -1,11 +1,14 @@
 ---
 source: crates/rome_formatter/tests/spec_test.rs
-assertion_line: 43
+assertion_line: 57
 expression: class.js
 
 ---
 # Input
 class Foo extends Boar {
+	static { // some comment
+		this.a = "test";
+	}
 	constructor(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb, c = d) {
 		super();
 	}
@@ -47,6 +50,10 @@ x = class aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa extends bbbbbbb
 ---
 # Output
 class Foo extends Boar {
+	static {
+		// some comment
+		this.a = "test";
+	}
 	constructor(
 		aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,
 		bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,

crates/rome_formatter/tests/specs/js/module/template/template.js

@@ -0,0 +1,18 @@
+`something`;
+
+tag`something`
+`something ${ " hello" }`;
+
+`something ${ () => { var hey; const looooooooooong_expression = "loooooooooong_expression" }} something else ${ ehy }`;
+    `something ${ () => { var hey; const looooooooooong_expression = "loooooooooong_expression"; return hey; }} something else ${ ehy }`;
+
+
+`test
+  abcd ${input}
+output
+`;
+
+`test
+  abcd ${ () => { var hey; const looooooooooong_expression = "loooooooooong_expression"; return hey; }}
+output
+`;

crates/rome_formatter/tests/specs/js/module/template/template.js.snap

@@ -0,0 +1,55 @@
+---
+source: crates/rome_formatter/tests/spec_test.rs
+assertion_line: 57
+expression: template.js
+
+---
+# Input
+`something`;
+
+tag`something`
+`something ${ " hello" }`;
+
+`something ${ () => { var hey; const looooooooooong_expression = "loooooooooong_expression" }} something else ${ ehy }`;
+    `something ${ () => { var hey; const looooooooooong_expression = "loooooooooong_expression"; return hey; }} something else ${ ehy }`;
+
+
+`test
+  abcd ${input}
+output
+`;
+
+`test
+  abcd ${ () => { var hey; const looooooooooong_expression = "loooooooooong_expression"; return hey; }}
+output
+`;
+---
+# Output
+`something`;
+
+tag`something``something ${" hello"}`;
+
+`something ${() => {
+	var hey;
+	const looooooooooong_expression = "loooooooooong_expression";
+}} something else ${ehy}`;
+`something ${() => {
+	var hey;
+	const looooooooooong_expression = "loooooooooong_expression";
+	return hey;
+}} something else ${ehy}`;
+
+`test
+  abcd ${input}
+output
+`;
+
+`test
+  abcd ${() => {
+	var hey;
+	const looooooooooong_expression = "loooooooooong_expression";
+	return hey;
+}}
+output
+`;
+

crates/rslint_parser/src/ast/expr_ext.rs

@@ -307,7 +307,7 @@ impl JsStringLiteralExpression {
     }
 }
 
-impl Template {
+impl JsTemplate {
     /// The string chunks of the template. aka:
     /// `foo ${bar} foo` breaks down into:
     /// `QUASIS ELEMENT{EXPR} QUASIS`