feat(rome_js_formatter): Template formatting (rome#3063)

crates/rome_formatter/src/builders.rs

@@ -1504,6 +1504,7 @@ impl<Context> Format<Context> for ExpandParent {
 /// ```
 /// use rome_formatter::{format_args, format, LineWidth};
 /// use rome_formatter::prelude::*;
+/// use rome_formatter::printer::PrintWidth;
 ///
 /// let context = SimpleFormatContext {
 ///     line_width: LineWidth::try_from(20).unwrap(),
@@ -1525,10 +1526,6 @@ impl<Context> Format<Context> for ExpandParent {
 ///     ])
 /// ]).unwrap();
 ///
-/// let options = PrinterOptions {
-///     print_width: LineWidth::try_from(20).unwrap(),
-///     ..PrinterOptions::default()
-/// };
 /// assert_eq!(
 ///     "[\n\t'A somewhat longer string to force a line break',\n\t2,\n\t3,\n]",
 ///     elements.print().as_code()

crates/rome_formatter/src/format_element.rs

@@ -777,7 +777,7 @@ impl FormatContext for IrFormatContext {
     fn as_print_options(&self) -> PrinterOptions {
         PrinterOptions {
             tab_width: 2,
-            print_width: self.line_width(),
+            print_width: self.line_width().into(),
             line_ending: LineEnding::LineFeed,
             indent_style: IndentStyle::Space(2),
         }

crates/rome_formatter/src/lib.rs

@@ -270,7 +270,7 @@ impl FormatContext for SimpleFormatContext {
     fn as_print_options(&self) -> PrinterOptions {
         PrinterOptions::default()
             .with_indent(self.indent_style)
-            .with_print_width(self.line_width)
+            .with_print_width(self.line_width.into())
     }
 }
 

crates/rome_formatter/src/printer/mod.rs

@@ -942,7 +942,7 @@ fn fits_element_on_line<'a, 'rest>(
                 state.line_width += char_width as usize;
             }
 
-            if state.line_width > options.print_width.value().into() {
+            if state.line_width > options.print_width.into() {
                 return Fits::No;
             }
 
@@ -1080,8 +1080,8 @@ impl<'a, 'rest> MeasureQueue<'a, 'rest> {
 #[cfg(test)]
 mod tests {
     use crate::prelude::*;
-    use crate::printer::{LineEnding, Printer, PrinterOptions};
-    use crate::{format_args, write, FormatState, IndentStyle, LineWidth, Printed, VecBuffer};
+    use crate::printer::{LineEnding, PrintWidth, Printer, PrinterOptions};
+    use crate::{format_args, write, FormatState, IndentStyle, Printed, VecBuffer};
 
     fn format(root: &dyn Format<()>) -> Printed {
         format_with_options(
@@ -1230,7 +1230,7 @@ two lines`,
         let options = PrinterOptions {
             indent_style: IndentStyle::Tab,
             tab_width: 4,
-            print_width: LineWidth::try_from(19).unwrap(),
+            print_width: PrintWidth::new(19),
             ..PrinterOptions::default()
         };
 
@@ -1315,7 +1315,7 @@ two lines`,
 
         let document = buffer.into_element();
 
-        let printed = Printer::new(PrinterOptions::default().with_print_width(LineWidth(10)))
+        let printed = Printer::new(PrinterOptions::default().with_print_width(PrintWidth::new(10)))
             .print(&document);
 
         assert_eq!(

crates/rome_formatter/src/printer/printer_options/mod.rs

@@ -7,7 +7,7 @@ pub struct PrinterOptions {
     pub tab_width: u8,
 
     /// What's the max width of a line. Defaults to 80
-    pub print_width: LineWidth,
+    pub print_width: PrintWidth,
 
     /// The type of line ending to apply to the printed input
     pub line_ending: LineEnding,
@@ -16,8 +16,42 @@ pub struct PrinterOptions {
     pub indent_style: IndentStyle,
 }
 
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+pub struct PrintWidth(u32);
+
+impl PrintWidth {
+    pub fn new(width: u32) -> Self {
+        Self(width)
+    }
+
+    /// Returns a print width that guarantees that any content, regardless of its width, fits on the line.
+    ///
+    /// This has the effect that the printer never prints a line break for any soft line break.
+    pub fn infinite() -> Self {
+        Self(u32::MAX)
+    }
+}
+
+impl Default for PrintWidth {
+    fn default() -> Self {
+        LineWidth::default().into()
+    }
+}
+
+impl From<LineWidth> for PrintWidth {
+    fn from(width: LineWidth) -> Self {
+        Self(u16::from(width) as u32)
+    }
+}
+
+impl From<PrintWidth> for usize {
+    fn from(width: PrintWidth) -> Self {
+        width.0 as usize
+    }
+}
+
 impl PrinterOptions {
-    pub fn with_print_width(mut self, width: LineWidth) -> Self {
+    pub fn with_print_width(mut self, width: PrintWidth) -> Self {
         self.print_width = width;
         self
     }
@@ -69,7 +103,7 @@ impl Default for PrinterOptions {
     fn default() -> Self {
         PrinterOptions {
             tab_width: 2,
-            print_width: LineWidth::default(),
+            print_width: PrintWidth::default(),
             indent_style: Default::default(),
             line_ending: LineEnding::LineFeed,
         }

crates/rome_js_formatter/src/context.rs

@@ -105,7 +105,7 @@ impl FormatContext for JsFormatContext {
     fn as_print_options(&self) -> PrinterOptions {
         PrinterOptions::default()
             .with_indent(self.indent_style)
-            .with_print_width(self.line_width)
+            .with_print_width(self.line_width.into())
     }
 }
 
@@ -160,7 +160,10 @@ impl CommentStyle<JsLanguage> for JsCommentStyle {
     fn is_group_start_token(&self, kind: JsSyntaxKind) -> bool {
         matches!(
             kind,
-            JsSyntaxKind::L_PAREN | JsSyntaxKind::L_BRACK | JsSyntaxKind::L_CURLY
+            JsSyntaxKind::L_PAREN
+                | JsSyntaxKind::L_BRACK
+                | JsSyntaxKind::L_CURLY
+                | JsSyntaxKind::DOLLAR_CURLY
         )
     }
 

crates/rome_js_formatter/src/js/expressions/arrow_function_expression.rs

@@ -3,8 +3,8 @@ use rome_formatter::{format_args, write};
 
 use crate::utils::{is_simple_expression, resolve_expression, starts_with_no_lookahead_token};
 use rome_js_syntax::{
-    JsAnyArrowFunctionParameters, JsAnyExpression, JsAnyFunctionBody, JsArrowFunctionExpression,
-    JsArrowFunctionExpressionFields,
+    JsAnyArrowFunctionParameters, JsAnyExpression, JsAnyFunctionBody, JsAnyTemplateElement,
+    JsArrowFunctionExpression, JsArrowFunctionExpressionFields, JsTemplate,
 };
 
 #[derive(Debug, Clone, Default)]
@@ -99,6 +99,9 @@ impl FormatNodeRule<JsArrowFunctionExpression> for FormatJsArrowFunctionExpressi
                     false,
                     !starts_with_no_lookahead_token(conditional.clone().into())?,
                 ),
+                JsTemplate(template) => {
+                    (is_multiline_template_starting_on_same_line(template), false)
+                }
                 expr => (is_simple_expression(expr)?, false),
             },
         };
@@ -125,3 +128,59 @@ impl FormatNodeRule<JsArrowFunctionExpression> for FormatJsArrowFunctionExpressi
         }
     }
 }
+
+/// Returns `true` if the template contains any new lines inside of its text chunks.
+fn template_literal_contains_new_line(template: &JsTemplate) -> bool {
+    template.elements().iter().any(|element| match element {
+        JsAnyTemplateElement::JsTemplateChunkElement(chunk) => chunk
+            .template_chunk_token()
+            .map_or(false, |chunk| chunk.text().contains('\n')),
+        JsAnyTemplateElement::JsTemplateElement(_) => false,
+    })
+}
+
+/// Returns `true` for a template that starts on the same line as the previous token and contains a line break.
+///
+///
+/// # Examples
+//
+/// ```javascript
+/// "test" + `
+///   some content
+/// `;
+/// ```
+///
+/// Returns `true` because the template starts on the same line as the `+` token and its text contains a line break.
+///
+/// ```javascript
+/// "test" + `no line break`
+/// ```
+///
+/// Returns `false` because the template text contains no line break.
+///
+/// ```javascript
+/// "test" +
+///     `template
+///     with line break`;
+/// ```
+///
+/// Returns `false` because the template isn't on the same line as the '+' token.
+fn is_multiline_template_starting_on_same_line(template: &JsTemplate) -> bool {
+    let contains_new_line = template_literal_contains_new_line(template);
+
+    let starts_on_same_line = template.syntax().first_token().map_or(false, |token| {
+        for piece in token.leading_trivia().pieces() {
+            if let Some(comment) = piece.as_comments() {
+                if comment.has_newline() {
+                    return false;
+                }
+            } else if piece.is_newline() {
+                return false;
+            }
+        }
+
+        true
+    });
+
+    contains_new_line && starts_on_same_line
+}

crates/rome_js_formatter/src/js/expressions/template.rs

@@ -1,32 +1,79 @@
 use crate::prelude::*;
 use rome_formatter::write;
 
-use rome_js_syntax::JsTemplate;
-use rome_js_syntax::JsTemplateFields;
+use rome_js_syntax::{
+    JsAnyExpression, JsSyntaxToken, JsTemplate, TsTemplateLiteralType, TsTypeArguments,
+};
+use rome_rowan::{declare_node_union, SyntaxResult};
 
 #[derive(Debug, Clone, Default)]
 pub struct FormatJsTemplate;
 
 impl FormatNodeRule<JsTemplate> for FormatJsTemplate {
     fn fmt_fields(&self, node: &JsTemplate, f: &mut JsFormatter) -> FormatResult<()> {
-        let JsTemplateFields {
-            tag,
-            type_arguments,
-            l_tick_token,
-            elements,
-            r_tick_token,
-        } = node.as_fields();
-
-        write![
+        JsAnyTemplate::from(node.clone()).fmt(f)
+    }
+}
+
+declare_node_union! {
+    JsAnyTemplate = JsTemplate | TsTemplateLiteralType
+}
+
+impl Format<JsFormatContext> for JsAnyTemplate {
+    fn fmt(&self, f: &mut Formatter<JsFormatContext>) -> FormatResult<()> {
+        write!(
             f,
             [
-                tag.format(),
-                type_arguments.format(),
+                self.tag().format(),
+                self.type_arguments().format(),
                 line_suffix_boundary(),
-                l_tick_token.format(),
-                elements.format(),
-                r_tick_token.format()
+                self.l_tick_token().format(),
             ]
-        ]
+        )?;
+
+        self.write_elements(f)?;
+
+        write!(f, [self.r_tick_token().format()])
+    }
+}
+
+impl JsAnyTemplate {
+    fn tag(&self) -> Option<JsAnyExpression> {
+        match self {
+            JsAnyTemplate::JsTemplate(template) => template.tag(),
+            JsAnyTemplate::TsTemplateLiteralType(_) => None,
+        }
+    }
+
+    fn type_arguments(&self) -> Option<TsTypeArguments> {
+        match self {
+            JsAnyTemplate::JsTemplate(template) => template.type_arguments(),
+            JsAnyTemplate::TsTemplateLiteralType(_) => None,
+        }
+    }
+
+    fn l_tick_token(&self) -> SyntaxResult<JsSyntaxToken> {
+        match self {
+            JsAnyTemplate::JsTemplate(template) => template.l_tick_token(),
+            JsAnyTemplate::TsTemplateLiteralType(template) => template.l_tick_token(),
+        }
+    }
+
+    fn write_elements(&self, f: &mut JsFormatter) -> FormatResult<()> {
+        match self {
+            JsAnyTemplate::JsTemplate(template) => {
+                write!(f, [template.elements().format()])
+            }
+            JsAnyTemplate::TsTemplateLiteralType(template) => {
+                write!(f, [template.elements().format()])
+            }
+        }
+    }
+
+    fn r_tick_token(&self) -> SyntaxResult<JsSyntaxToken> {
+        match self {
+            JsAnyTemplate::JsTemplate(template) => template.r_tick_token(),
+            JsAnyTemplate::TsTemplateLiteralType(template) => template.r_tick_token(),
+        }
     }
 }

crates/rome_js_formatter/src/js/expressions/template_chunk_element.rs

@@ -1,7 +1,8 @@
 use crate::prelude::*;
-use crate::utils::format_template_chunk;
+use rome_formatter::write;
 
-use rome_js_syntax::{JsTemplateChunkElement, JsTemplateChunkElementFields};
+use rome_js_syntax::{JsSyntaxToken, JsTemplateChunkElement, TsTemplateChunkElement};
+use rome_rowan::{declare_node_union, SyntaxResult};
 
 #[derive(Debug, Clone, Default)]
 pub struct FormatJsTemplateChunkElement;
@@ -12,11 +13,39 @@ impl FormatNodeRule<JsTemplateChunkElement> for FormatJsTemplateChunkElement {
         node: &JsTemplateChunkElement,
         formatter: &mut JsFormatter,
     ) -> FormatResult<()> {
-        let JsTemplateChunkElementFields {
-            template_chunk_token,
-        } = node.as_fields();
+        AnyTemplateChunkElement::from(node.clone()).fmt(formatter)
+    }
+}
+
+declare_node_union! {
+    pub(crate) AnyTemplateChunkElement = JsTemplateChunkElement | TsTemplateChunkElement
+}
+
+impl AnyTemplateChunkElement {
+    pub(crate) fn template_chunk_token(&self) -> SyntaxResult<JsSyntaxToken> {
+        match self {
+            AnyTemplateChunkElement::JsTemplateChunkElement(chunk) => chunk.template_chunk_token(),
+            AnyTemplateChunkElement::TsTemplateChunkElement(chunk) => chunk.template_chunk_token(),
+        }
+    }
+}
+
+impl Format<JsFormatContext> for AnyTemplateChunkElement {
+    fn fmt(&self, f: &mut Formatter<JsFormatContext>) -> FormatResult<()> {
+        let chunk = self.template_chunk_token()?;
 
-        let chunk = template_chunk_token?;
-        format_template_chunk(chunk, formatter)
+        write!(
+            f,
+            [format_replaced(
+                &chunk,
+                &syntax_token_cow_slice(
+                    // Per https://tc39.es/ecma262/multipage/ecmascript-language-lexical-grammar.html#sec-static-semantics-trv:
+                    // In template literals, the '\r' and '\r\n' line terminators are normalized to '\n'
+                    normalize_newlines(chunk.text_trimmed(), ['\r']),
+                    &chunk,
+                    chunk.text_trimmed_range().start(),
+                )
+            )]
+        )
     }
 }