diff --git a/crates/rome_formatter/src/arguments.rs b/crates/rome_formatter/src/arguments.rs index a7c9aec719d..a922581ccef 100644 --- a/crates/rome_formatter/src/arguments.rs +++ b/crates/rome_formatter/src/arguments.rs @@ -1,5 +1,5 @@ use super::{Buffer, Format, Formatter}; -use crate::{FormatContext, FormatResult, Formatted}; +use crate::FormatResult; use std::ffi::c_void; use std::marker::PhantomData; @@ -9,7 +9,6 @@ use std::marker::PhantomData; /// This struct is similar to a dynamic dispatch (using `dyn Format`) because it stores a pointer to the value. /// However, it doesn't store the pointer to `dyn Format`'s vtable, instead it statically resolves the function /// pointer of `Format::format` and stores it in `formatter`. -#[derive(Copy, Clone)] pub struct Argument<'fmt, Context> { /// The value to format stored as a raw pointer where `lifetime` stores the value's lifetime. value: *const c_void, @@ -21,6 +20,13 @@ pub struct Argument<'fmt, Context> { formatter: fn(*const c_void, &mut Formatter<'_, Context>) -> FormatResult<()>, } +impl Clone for Argument<'_, Context> { + fn clone(&self) -> Self { + *self + } +} +impl Copy for Argument<'_, Context> {} + impl<'fmt, Context> Argument<'fmt, Context> { /// Called by the [rome_formatter::format_args] macro. Creates a mono-morphed value for formatting /// an object. @@ -32,7 +38,7 @@ impl<'fmt, Context> Argument<'fmt, Context> { fmt: &mut Formatter, ) -> FormatResult<()> { // SAFETY: Safe because the 'fmt lifetime is captured by the 'lifetime' field. - F::format(unsafe { &*(ptr as *const F) }, fmt) + F::fmt(unsafe { &*(ptr as *const F) }, fmt) } Self { @@ -41,12 +47,10 @@ impl<'fmt, Context> Argument<'fmt, Context> { formatter: formatter::, } } -} -impl Format for Argument<'_, Context> { /// Formats the value stored by this argument using the given formatter. #[inline] - fn format(&self, f: &mut Formatter) -> FormatResult<()> { + pub(super) fn format(&self, f: &mut Formatter) -> FormatResult<()> { (self.formatter)(self.value, f) } } @@ -94,20 +98,14 @@ impl Clone for Arguments<'_, Context> { impl Format for Arguments<'_, Context> { #[inline] - fn format(&self, formatter: &mut Formatter) -> FormatResult<()> { + fn fmt(&self, formatter: &mut Formatter) -> FormatResult<()> { formatter.write_fmt(*self) } } -impl std::fmt::Debug for Arguments<'_, Context> -where - Context: Default + FormatContext, -{ +impl std::fmt::Debug for Arguments<'_, Context> { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - match crate::format!(Context::default(), [self]) { - Ok(formatted) => Formatted::fmt(&formatted, f), - Err(err) => std::write!(f, "Err({err})"), - } + f.write_str("Arguments[...]") } } @@ -128,7 +126,7 @@ mod tests { space_token(), token("a"), space_token(), - group_elements(format_args!(token("("), token(")"))) + group_elements(&format_args!(token("("), token(")"))) ] ) .unwrap(); diff --git a/crates/rome_formatter/src/buffer.rs b/crates/rome_formatter/src/buffer.rs index 9a878cc9f70..f22341453ed 100644 --- a/crates/rome_formatter/src/buffer.rs +++ b/crates/rome_formatter/src/buffer.rs @@ -156,6 +156,8 @@ impl + ?Sized, Context> Buffer for &mut W { } /// Vector backed [`Buffer`] implementation. +/// +/// The buffer writes all elements into the internal elements buffer. #[derive(Debug)] pub struct VecBuffer<'a, Context> { state: &'a mut FormatState, @@ -170,6 +172,7 @@ impl<'a, Context> VecBuffer<'a, Context> { } } + /// Creates a buffer with the specified capacity pub fn with_capacity(capacity: usize, context: &'a mut FormatState) -> Self { Self { state: context, @@ -244,15 +247,19 @@ impl Buffer for VecBuffer<'_, Context> { fn restore_snapshot(&mut self, snapshot: BufferSnapshot) { let position = snapshot.unwrap_position(); - assert!(self.elements.len() >= position); + assert!( + self.elements.len() >= position, + r#"Outdated snapshot. This buffer contains fewer elements than at the time the snapshot was taken. +Make sure that you take and restore the snapshot in order and that this snapshot belongs to the current buffer."# + ); - self.elements.truncate(position) + self.elements.truncate(position); } } -/// Buffer that writes a pre-amble before the first written content. +/// This struct wraps an existing buffer and emits a preamble text when the first text is written. /// -/// Useful to conditionally write some content. +/// This can be useful if you, for example, want to write some content if what gets written next isn't empty. /// /// # Examples /// @@ -266,7 +273,7 @@ impl Buffer for VecBuffer<'_, Context> { /// struct Preamble; /// /// impl Format for Preamble { -/// fn format(&self, f: &mut Formatter) -> FormatResult<()> { +/// fn fmt(&self, f: &mut Formatter) -> FormatResult<()> { /// write!(f, [token("# heading"), hard_line_break()]) /// } /// } @@ -293,7 +300,7 @@ impl Buffer for VecBuffer<'_, Context> { /// struct Preamble; /// /// impl Format for Preamble { -/// fn format(&self, f: &mut Formatter) -> FormatResult<()> { +/// fn fmt(&self, f: &mut Formatter) -> FormatResult<()> { /// write!(f, [token("# heading"), hard_line_break()]) /// } /// } @@ -311,7 +318,7 @@ pub struct PreambleBuffer<'buf, Preamble, Context> { /// The pre-amble to write once the first content gets written to this buffer. preamble: Preamble, - /// Whatever some content (including the pre-amble) has been written at this point. + /// Whether some content (including the pre-amble) has been written at this point. empty: bool, } @@ -372,3 +379,56 @@ struct PreambleBufferSnapshot { inner: BufferSnapshot, empty: bool, } + +/// Buffer that allows you inspecting elements as they get written to the formatter. +pub struct Inspect<'inner, Context, Inspector> { + inner: &'inner mut dyn Buffer, + inspector: Inspector, +} + +impl<'inner, Context, Inspector> Inspect<'inner, Context, Inspector> { + pub fn new(inner: &'inner mut dyn Buffer, inspector: Inspector) -> Self { + Self { inner, inspector } + } +} + +impl<'inner, Context, Inspector> Buffer for Inspect<'inner, Context, Inspector> +where + Inspector: FnMut(&FormatElement), +{ + type Context = Context; + + fn write_element(&mut self, element: FormatElement) -> FormatResult<()> { + (self.inspector)(&element); + self.inner.write_element(element) + } + + fn state(&self) -> &FormatState { + self.inner.state() + } + + fn state_mut(&mut self) -> &mut FormatState { + self.inner.state_mut() + } + + fn snapshot(&self) -> BufferSnapshot { + self.inner.snapshot() + } + + fn restore_snapshot(&mut self, snapshot: BufferSnapshot) { + self.inner.restore_snapshot(snapshot) + } +} + +pub trait BufferExtensions: Buffer + Sized { + /// Returns a new buffer that calls the passed inspector for every element that gets written to the output + #[must_use] + fn inspect(&mut self, inspector: F) -> Inspect + where + F: FnMut(&FormatElement), + { + Inspect::new(self, inspector) + } +} + +impl BufferExtensions for T where T: Buffer {} diff --git a/crates/rome_formatter/src/builders.rs b/crates/rome_formatter/src/builders.rs index 5c24f1a03d0..d3f77992f5a 100644 --- a/crates/rome_formatter/src/builders.rs +++ b/crates/rome_formatter/src/builders.rs @@ -1,8 +1,5 @@ use crate::prelude::*; -use crate::{ - format_element, write, Arguments, FormatContext, Formatted, GroupId, PreambleBuffer, TextRange, - TextSize, -}; +use crate::{format_element, write, Arguments, GroupId, PreambleBuffer, TextRange, TextSize}; use crate::{Buffer, VecBuffer}; use rome_rowan::{Language, SyntaxNode, SyntaxToken, SyntaxTokenText, TextLen}; use std::borrow::Cow; @@ -21,7 +18,7 @@ pub const fn empty_element() -> Empty { pub struct Empty; impl Format for Empty { - fn format(&self, _: &mut Formatter) -> FormatResult<()> { + fn fmt(&self, _: &mut Formatter) -> FormatResult<()> { Ok(()) } } @@ -39,7 +36,7 @@ impl Format for Empty { /// use rome_formatter::prelude::*; /// /// let elements = format!(SimpleFormatContext::default(), [ -/// group_elements(format_args![token("a,"), soft_line_break(), token("b")]) +/// group_elements(&format_args![token("a,"), soft_line_break(), token("b")]) /// ]).unwrap(); /// /// assert_eq!( @@ -55,13 +52,13 @@ impl Format for Empty { /// use rome_formatter::{format, format_args, LineWidth}; /// use rome_formatter::prelude::*; /// -/// let options = SimpleFormatContext { +/// let context = SimpleFormatContext { /// line_width: LineWidth::try_from(10).unwrap(), /// ..SimpleFormatContext::default() /// }; /// -/// let elements = format!(options, [ -/// group_elements(format_args![ +/// let elements = format!(context, [ +/// group_elements(&format_args![ /// token("a long word,"), /// soft_line_break(), /// token("so that the group doesn't fit on a single line"), @@ -89,7 +86,7 @@ pub const fn soft_line_break() -> Line { /// use rome_formatter::prelude::*; /// /// let elements = format!(SimpleFormatContext::default(), [ -/// group_elements(format_args![ +/// group_elements(&format_args![ /// token("a,"), /// hard_line_break(), /// token("b"), @@ -118,7 +115,7 @@ pub const fn hard_line_break() -> Line { /// /// let elements = format!( /// SimpleFormatContext::default(), [ -/// group_elements(format_args![ +/// group_elements(&format_args![ /// token("a,"), /// empty_line(), /// token("b"), @@ -146,7 +143,7 @@ pub const fn empty_line() -> Line { /// use rome_formatter::prelude::*; /// /// let elements = format!(SimpleFormatContext::default(), [ -/// group_elements(format_args![ +/// group_elements(&format_args![ /// token("a,"), /// soft_line_break_or_space(), /// token("b"), @@ -164,13 +161,13 @@ pub const fn empty_line() -> Line { /// use rome_formatter::{format_args, format, LineWidth}; /// use rome_formatter::prelude::*; /// -/// let options = SimpleFormatContext { +/// let context = SimpleFormatContext { /// line_width: LineWidth::try_from(10).unwrap(), /// ..SimpleFormatContext::default() /// }; /// -/// let elements = format!(options, [ -/// group_elements(format_args![ +/// let elements = format!(context, [ +/// group_elements(&format_args![ /// token("a long word,"), /// soft_line_break_or_space(), /// token("so that the group doesn't fit on a single line"), @@ -199,7 +196,7 @@ impl Line { } impl Format for Line { - fn format(&self, f: &mut Formatter) -> FormatResult<()> { + fn fmt(&self, f: &mut Formatter) -> FormatResult<()> { f.write_element(FormatElement::Line(self.mode)) } } @@ -256,7 +253,7 @@ pub struct StaticToken { } impl Format for StaticToken { - fn format(&self, f: &mut Formatter) -> FormatResult<()> { + fn fmt(&self, f: &mut Formatter) -> FormatResult<()> { f.write_element(FormatElement::Token(Token::Static { text: self.text })) } } @@ -281,7 +278,7 @@ pub struct DynamicToken<'a> { } impl Format for DynamicToken<'_> { - fn format(&self, f: &mut Formatter) -> FormatResult<()> { + fn fmt(&self, f: &mut Formatter) -> FormatResult<()> { f.write_element(FormatElement::Token(Token::Dynamic { text: self.text.to_string().into_boxed_str(), source_position: self.position, @@ -314,7 +311,7 @@ pub struct SyntaxTokenCowSlice<'a, L: Language> { } impl Format for SyntaxTokenCowSlice<'_, L> { - fn format(&self, f: &mut Formatter) -> FormatResult<()> { + fn fmt(&self, f: &mut Formatter) -> FormatResult<()> { match &self.text { Cow::Borrowed(text) => { let range = TextRange::at(self.start, text.text_len()); @@ -368,7 +365,7 @@ pub struct SyntaxTokenTextSlice { } impl Format for SyntaxTokenTextSlice { - fn format(&self, f: &mut Formatter) -> FormatResult<()> { + fn fmt(&self, f: &mut Formatter) -> FormatResult<()> { f.write_element(FormatElement::Token(Token::SyntaxTokenSlice { slice: self.text.clone(), source_position: self.source_position, @@ -396,7 +393,7 @@ fn debug_assert_no_newlines(text: &str) { /// /// let elements = format!(SimpleFormatContext::default(), [ /// token("a"), -/// line_suffix(token("c")), +/// line_suffix(&token("c")), /// token("b") /// ]).unwrap(); /// @@ -406,20 +403,17 @@ fn debug_assert_no_newlines(text: &str) { /// ); /// ``` #[inline] -pub const fn line_suffix(inner: Content) -> LineSuffix { +pub const fn line_suffix(inner: &dyn Format) -> LineSuffix { LineSuffix { content: inner } } -#[derive(Copy, Clone, Eq, PartialEq)] -pub struct LineSuffix { - content: Content, +#[derive(Copy, Clone)] +pub struct LineSuffix<'a, Context> { + content: &'a dyn Format, } -impl Format for LineSuffix -where - Content: Format, -{ - fn format(&self, f: &mut Formatter) -> FormatResult<()> { +impl Format for LineSuffix<'_, Context> { + fn fmt(&self, f: &mut Formatter) -> FormatResult<()> { let mut buffer = VecBuffer::new(f.state_mut()); write!(buffer, [&self.content])?; @@ -428,12 +422,9 @@ where } } -impl std::fmt::Debug for LineSuffix -where - Content: std::fmt::Debug, -{ +impl std::fmt::Debug for LineSuffix<'_, Context> { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - f.debug_tuple("LineSuffix").field(&self.content).finish() + f.debug_tuple("LineSuffix").field(&"{{content}}").finish() } } @@ -449,7 +440,7 @@ where /// /// let elements = format!(SimpleFormatContext::default(), [ /// token("a"), -/// line_suffix(token("c")), +/// line_suffix(&token("c")), /// token("b"), /// line_suffix_boundary(), /// token("d") @@ -468,7 +459,7 @@ pub const fn line_suffix_boundary() -> LineSuffixBoundary { pub struct LineSuffixBoundary; impl Format for LineSuffixBoundary { - fn format(&self, f: &mut Formatter) -> FormatResult<()> { + fn fmt(&self, f: &mut Formatter) -> FormatResult<()> { f.write_element(FormatElement::LineSuffixBoundary) } } @@ -487,8 +478,8 @@ impl Format for LineSuffixBoundary { /// let elements = format!( /// SimpleFormatContext::default(), /// [ -/// group_elements(format_args![ -/// comment(empty_line()), +/// group_elements(&format_args![ +/// comment(&empty_line()), /// token("a"), /// soft_line_break_or_space(), /// token("b") @@ -502,20 +493,17 @@ impl Format for LineSuffixBoundary { /// ); /// ``` #[inline] -pub const fn comment(content: Content) -> Comment { +pub const fn comment(content: &dyn Format) -> Comment { Comment { content } } -#[derive(Copy, Clone, Eq, PartialEq)] -pub struct Comment { - content: Content, +#[derive(Copy, Clone)] +pub struct Comment<'a, Context> { + content: &'a dyn Format, } -impl Format for Comment -where - Content: Format, -{ - fn format(&self, f: &mut Formatter) -> FormatResult<()> { +impl Format for Comment<'_, Context> { + fn fmt(&self, f: &mut Formatter) -> FormatResult<()> { let mut buffer = VecBuffer::new(f.state_mut()); write!(buffer, [&self.content])?; @@ -525,12 +513,9 @@ where } } -impl std::fmt::Debug for Comment -where - Content: std::fmt::Debug, -{ +impl std::fmt::Debug for Comment<'_, Context> { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - f.debug_tuple("Comment").field(&self.content).finish() + f.debug_tuple("Comment").field(&"{{content}}").finish() } } @@ -556,7 +541,7 @@ pub const fn space_token() -> Space { pub struct Space; impl Format for Space { - fn format(&self, f: &mut Formatter) -> FormatResult<()> { + fn fmt(&self, f: &mut Formatter) -> FormatResult<()> { f.write_element(FormatElement::Space) } } @@ -577,9 +562,9 @@ impl Format for Space { /// /// let block = format!(SimpleFormatContext::default(), [ /// token("switch {"), -/// block_indent(format_args![ +/// block_indent(&format_args![ /// token("default:"), -/// indent(format_args![ +/// indent(&format_args![ /// // this is where we want to use a /// hard_line_break(), /// token("break;"), @@ -594,20 +579,17 @@ impl Format for Space { /// ); /// ``` #[inline] -pub const fn indent(content: Content) -> Indent { +pub const fn indent(content: &dyn Format) -> Indent { Indent { content } } -#[derive(Copy, Clone, Eq, PartialEq)] -pub struct Indent { - content: Content, +#[derive(Copy, Clone)] +pub struct Indent<'a, Context> { + content: &'a dyn Format, } -impl Format for Indent -where - Content: Format, -{ - fn format(&self, f: &mut Formatter) -> FormatResult<()> { +impl Format for Indent<'_, Context> { + fn fmt(&self, f: &mut Formatter) -> FormatResult<()> { let mut buffer = VecBuffer::new(f.state_mut()); write!(buffer, [&self.content])?; @@ -621,12 +603,9 @@ where } } -impl std::fmt::Debug for Indent -where - Content: std::fmt::Debug, -{ +impl std::fmt::Debug for Indent<'_, Context> { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - f.debug_tuple("Indent").field(&self.content).finish() + f.debug_tuple("Indent").field(&"{{content}}").finish() } } @@ -647,7 +626,7 @@ where /// SimpleFormatContext::default(), /// [ /// token("{"), -/// block_indent(format_args![ +/// block_indent(&format_args![ /// token("let a = 10;"), /// hard_line_break(), /// token("let c = a + 5;"), @@ -662,7 +641,7 @@ where /// ); /// ``` #[inline] -pub const fn block_indent(content: Content) -> BlockIndent { +pub const fn block_indent(content: &dyn Format) -> BlockIndent { BlockIndent { content, mode: IndentMode::Block, @@ -681,15 +660,15 @@ pub const fn block_indent(content: Content) -> BlockIndent { /// use rome_formatter::{format, format_args, LineWidth}; /// use rome_formatter::prelude::*; /// -/// let options = SimpleFormatContext { +/// let context = SimpleFormatContext { /// line_width: LineWidth::try_from(10).unwrap(), /// ..SimpleFormatContext::default() /// }; /// -/// let elements = format!(options, [ -/// group_elements(format_args![ +/// let elements = format!(context, [ +/// group_elements(&format_args![ /// token("["), -/// soft_block_indent(format_args![ +/// soft_block_indent(&format_args![ /// token("'First string',"), /// soft_line_break_or_space(), /// token("'second string',"), @@ -710,9 +689,9 @@ pub const fn block_indent(content: Content) -> BlockIndent { /// use rome_formatter::prelude::*; /// /// let elements = format!(SimpleFormatContext::default(), [ -/// group_elements(format_args![ +/// group_elements(&format_args![ /// token("["), -/// soft_block_indent(format_args![ +/// soft_block_indent(&format_args![ /// token("5,"), /// soft_line_break_or_space(), /// token("10"), @@ -727,7 +706,7 @@ pub const fn block_indent(content: Content) -> BlockIndent { /// ); /// ``` #[inline] -pub const fn soft_block_indent(content: Content) -> BlockIndent { +pub const fn soft_block_indent(content: &dyn Format) -> BlockIndent { BlockIndent { content, mode: IndentMode::Soft, @@ -749,17 +728,17 @@ pub const fn soft_block_indent(content: Content) -> BlockIndent(content: Content) -> BlockIndent "BlockIndent", - IndentMode::SoftLineOrSpace => "SoftLineOrSpace", + IndentMode::Soft => "SoftBlockIndent", + IndentMode::Block => "HardBlockIndent", + IndentMode::SoftLineOrSpace => "SoftLineIndentOrSpace", }; - f.debug_tuple(name).field(&self.content).finish() + f.debug_tuple(name).field(&"{{content}}").finish() } } @@ -882,9 +857,9 @@ where /// use rome_formatter::prelude::*; /// /// let elements = format!(SimpleFormatContext::default(), [ -/// group_elements(format_args![ +/// group_elements(&format_args![ /// token("["), -/// soft_block_indent(format_args![ +/// soft_block_indent(&format_args![ /// token("1,"), /// soft_line_break_or_space(), /// token("2,"), @@ -906,15 +881,15 @@ where /// use rome_formatter::{format, format_args, LineWidth}; /// use rome_formatter::prelude::*; /// -/// let options = SimpleFormatContext { +/// let context = SimpleFormatContext { /// line_width: LineWidth::try_from(20).unwrap(), /// ..SimpleFormatContext::default() /// }; /// -/// let elements = format!(options, [ -/// group_elements(format_args![ +/// let elements = format!(context, [ +/// group_elements(&format_args![ /// token("["), -/// soft_block_indent(format_args![ +/// soft_block_indent(&format_args![ /// token("'Good morning! How are you today?',"), /// soft_line_break_or_space(), /// token("2,"), @@ -931,43 +906,28 @@ where /// ); /// ``` #[inline] -pub const fn group_elements(content: Content) -> GroupElements { +pub const fn group_elements(content: &dyn Format) -> GroupElements { GroupElements { content, - options: GroupElementsOptions { group_id: None }, + group_id: None, } } -#[derive(Default, Clone, Copy, Debug, Eq, PartialEq)] -pub struct GroupElementsOptions { - pub group_id: Option, -} - -#[derive(Copy, Clone, Eq, PartialEq)] -pub struct GroupElements { - content: Content, - options: GroupElementsOptions, +#[derive(Copy, Clone)] +pub struct GroupElements<'a, Context> { + content: &'a dyn Format, + group_id: Option, } -impl GroupElements { - /// Creates a group with a specific id. Useful for cases where `if_group_breaks` and `if_group_fits_on_line` - /// shouldn't refer to the direct parent group. - pub fn with_options(mut self, options: GroupElementsOptions) -> Self { - self.options = options; - self - } - +impl GroupElements<'_, Context> { pub fn with_group_id(mut self, group_id: Option) -> Self { - self.options.group_id = group_id; + self.group_id = group_id; self } } -impl Format for GroupElements -where - Content: Format, -{ - fn format(&self, f: &mut Formatter) -> FormatResult<()> { +impl Format for GroupElements<'_, Context> { + fn fmt(&self, f: &mut Formatter) -> FormatResult<()> { let mut buffer = VecBuffer::new(f.state_mut()); write!(buffer, [self.content])?; @@ -975,7 +935,7 @@ where let content = buffer.into_element(); let (leading, content, trailing) = content.split_trivia(); - let group = Group::new(content).with_id(self.options.group_id); + let group = Group::new(content).with_id(self.group_id); if !leading.is_empty() { f.write_element(leading)?; @@ -990,19 +950,12 @@ where } } -impl std::fmt::Debug for GroupElements -where - Content: std::fmt::Debug, -{ +impl std::fmt::Debug for GroupElements<'_, Context> { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - if let Some(group_id) = self.options.group_id { - f.debug_struct("Group") - .field("content", &self.content) - .field("id", &group_id) - .finish() - } else { - f.debug_tuple("Group").field(&self.content).finish() - } + f.debug_struct("GroupElements") + .field("group_id", &self.group_id) + .field("content", &"{{content}}") + .finish() } } @@ -1017,9 +970,9 @@ where /// use rome_formatter::prelude::*; /// /// let elements = format!(SimpleFormatContext::default(), [ -/// group_elements(format_args![ +/// group_elements(&format_args![ /// token("["), -/// soft_block_indent(format_args![ +/// soft_block_indent(&format_args![ /// token("'Good morning! How are you today?',"), /// soft_line_break_or_space(), /// token("2,"), @@ -1047,7 +1000,7 @@ pub const fn expand_parent() -> ExpandParent { pub struct ExpandParent; impl Format for ExpandParent { - fn format(&self, f: &mut Formatter) -> FormatResult<()> { + fn fmt(&self, f: &mut Formatter) -> FormatResult<()> { f.write_element(FormatElement::ExpandParent) } } @@ -1068,15 +1021,15 @@ impl Format for ExpandParent { /// use rome_formatter::prelude::*; /// /// let elements = format!(SimpleFormatContext::default(), [ -/// group_elements(format_args![ +/// group_elements(&format_args![ /// token("["), -/// soft_block_indent(format_args![ +/// soft_block_indent(&format_args![ /// token("1,"), /// soft_line_break_or_space(), /// token("2,"), /// soft_line_break_or_space(), /// token("3"), -/// if_group_breaks(token(",")) +/// if_group_breaks(&token(",")) /// ]), /// token("]"), /// ]) @@ -1093,21 +1046,21 @@ impl Format for ExpandParent { /// use rome_formatter::{format_args, format, LineWidth}; /// use rome_formatter::prelude::*; /// -/// let options = SimpleFormatContext { +/// let context = SimpleFormatContext { /// line_width: LineWidth::try_from(20).unwrap(), /// ..SimpleFormatContext::default() /// }; /// -/// let elements = format!(options, [ -/// group_elements(format_args![ +/// let elements = format!(context, [ +/// group_elements(&format_args![ /// token("["), -/// soft_block_indent(format_args![ +/// soft_block_indent(&format_args![ /// token("'A somewhat longer string to force a line break',"), /// soft_line_break_or_space(), /// token("2,"), /// soft_line_break_or_space(), /// token("3"), -/// if_group_breaks(token(",")) +/// if_group_breaks(&token(",")) /// ]), /// token("]"), /// ]) @@ -1123,7 +1076,7 @@ impl Format for ExpandParent { /// ); /// ``` #[inline] -pub const fn if_group_breaks(content: Content) -> IfGroupBreaks { +pub const fn if_group_breaks(content: &dyn Format) -> IfGroupBreaks { IfGroupBreaks { content, group_id: None, @@ -1144,15 +1097,15 @@ pub const fn if_group_breaks(content: Content) -> IfGroupBreaks(content: Content) -> IfGroupBreaks(content: Content) -> IfGroupBreaks(flat_content: Content) -> IfGroupBreaks { +pub const fn if_group_fits_on_line( + flat_content: &dyn Format, +) -> IfGroupBreaks { IfGroupBreaks { mode: PrintMode::Flat, group_id: None, @@ -1203,14 +1158,14 @@ pub const fn if_group_fits_on_line(flat_content: Content) -> IfGroupBre } } -#[derive(Copy, Clone, Eq, PartialEq)] -pub struct IfGroupBreaks { - content: Content, +#[derive(Copy, Clone)] +pub struct IfGroupBreaks<'a, Context> { + content: &'a dyn Format, group_id: Option, mode: PrintMode, } -impl IfGroupBreaks { +impl IfGroupBreaks<'_, Context> { /// Inserts some content that the printer only prints if the group with the specified `group_id` /// is printed in multiline mode. The referred group must appear before this element in the document /// but doesn't have to one of its ancestors. @@ -1225,28 +1180,28 @@ impl IfGroupBreaks { /// use rome_formatter::{format, format_args, write, LineWidth}; /// use rome_formatter::prelude::*; /// - /// let options = SimpleFormatContext { + /// let context = SimpleFormatContext { /// line_width: LineWidth::try_from(20).unwrap(), /// ..SimpleFormatContext::default() /// }; /// - /// let formatted = format!(options, [format_with(|f| { + /// let formatted = format!(context, [format_with(|f| { /// let group_id = f.group_id("array"); /// /// write!(f, [ /// group_elements( - /// format_args![ + /// &format_args![ /// token("["), - /// soft_block_indent(format_with(|f| { + /// soft_block_indent(&format_with(|f| { /// f.fill(soft_line_break_or_space()) /// .entry(&token("1,")) /// .entry(&token("234568789,")) /// .entry(&token("3456789,")) /// .entry(&format_args!( /// token("["), - /// soft_block_indent(token("4")), + /// soft_block_indent(&token("4")), /// token("]"), - /// if_group_breaks(token(",")).with_group_id(Some(group_id)) + /// if_group_breaks(&token(",")).with_group_id(Some(group_id)) /// )) /// .finish() /// })), @@ -1267,11 +1222,8 @@ impl IfGroupBreaks { } } -impl Format for IfGroupBreaks -where - Content: Format, -{ - fn format(&self, f: &mut Formatter) -> FormatResult<()> { +impl Format for IfGroupBreaks<'_, Context> { + fn fmt(&self, f: &mut Formatter) -> FormatResult<()> { let mut buffer = VecBuffer::new(f.state_mut()); write!(buffer, [&self.content])?; @@ -1287,55 +1239,39 @@ where } } -impl std::fmt::Debug for IfGroupBreaks -where - Content: std::fmt::Debug, -{ +impl std::fmt::Debug for IfGroupBreaks<'_, Context> { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { let name = match self.mode { PrintMode::Flat => "IfGroupFitsOnLine", PrintMode::Expanded => "IfGroupBreaks", }; - if let Some(group_id) = self.group_id { - f.debug_struct(name) - .field("group_id", &group_id) - .field("content", &self.content) - .finish() - } else { - f.debug_tuple(name).field(&self.content).finish() - } + f.debug_struct(name) + .field("group_id", &self.group_id) + .field("content", &"{{content}}") + .finish() } } /// Utility for formatting some content with an inline lambda function. #[derive(Copy, Clone)] pub struct FormatWith { - closure: T, - options: PhantomData, + formatter: T, + context: PhantomData, } impl Format for FormatWith where T: Fn(&mut Formatter) -> FormatResult<()>, { - fn format(&self, f: &mut Formatter) -> FormatResult<()> { - (self.closure)(f) + fn fmt(&self, f: &mut Formatter) -> FormatResult<()> { + (self.formatter)(f) } } -impl std::fmt::Debug for FormatWith -where - T: Fn(&mut Formatter) -> FormatResult<()>, - Context: Default + FormatContext, -{ +impl std::fmt::Debug for FormatWith { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - match crate::format!(Context::default(), [&self]) { - Ok(formatted) => Formatted::fmt(&formatted, f), - Err(err) => { - std::write!(f, "Err({err})") - } - } + f.debug_tuple("FormatWith").field(&"{{formatter}}").finish() } } @@ -1353,12 +1289,12 @@ where /// } /// /// impl Format for MyFormat { -/// fn format(&self, f: &mut Formatter) -> FormatResult<()> { +/// fn fmt(&self, f: &mut Formatter) -> FormatResult<()> { /// write!(f, [ /// token("("), -/// block_indent(format_with(|f| { +/// block_indent(&format_with(|f| { /// let separator = space_token(); -/// let mut join = f.join_with(separator); +/// let mut join = f.join_with(&separator); /// /// for item in &self.items { /// join.entry(&format_with(|f| write!(f, [dynamic_token(item, TextSize::default())]))); @@ -1374,18 +1310,23 @@ where /// /// assert_eq!("(\n\ta b c\n)", formatted.print().as_code()); /// ``` -pub const fn format_with(closure: T) -> FormatWith +pub const fn format_with(formatter: T) -> FormatWith where T: Fn(&mut Formatter) -> FormatResult<()>, { FormatWith { - closure, - options: PhantomData, + formatter, + context: PhantomData, } } /// Creates an inline `Format` object that can only be formatted once. /// +/// This can be useful in situation where the borrow checker doesn't allow you to use [`format_with`] +/// because the code formatting the content consumes the value and cloning the value is too expensive. +/// An example of this is if you want to nest a `FormatElement` or non-cloneable `Iterator` inside of a +/// `block_indent` as shown can see in the examples section. +/// /// # Panics /// /// Panics if the object gets formatted more than once. @@ -1395,75 +1336,99 @@ where /// ``` /// use rome_formatter::prelude::*; /// use rome_formatter::{SimpleFormatContext, format, write, Buffer}; -/// use rome_rowan::TextSize; /// -/// struct MyFormat { -/// items: Vec<&'static str>, +/// struct MyFormat; +/// +/// fn generate_values() -> impl Iterator { +/// vec![token("1"), token("2"), token("3"), token("4")].into_iter() /// } /// /// impl Format for MyFormat { -/// fn format(&self, f: &mut Formatter) -> FormatResult<()> { -/// // Some owned value that you want to format inside of a nested element -/// let element = FormatElement::Comment(Box::new(FormatElement::Token(Token::Static { text: "test" }))); +/// fn fmt(&self, f: &mut Formatter) -> FormatResult<()> { +/// let mut values = generate_values(); /// +/// let first = values.next(); +/// +/// // Formats the first item outside of the block and all other items inside of the block, +/// // separated by line breaks /// write!(f, [ -/// token("("), -/// block_indent(format_once(|f| { -/// f.write_element(element) +/// first, +/// block_indent(&format_once(|f| { +/// // Using format_with isn't possible here because the iterator gets consumed here +/// f.join_with(&hard_line_break()).entries(values).finish() /// })), -/// token(")") /// ]) /// } /// } /// -/// let formatted = format!(SimpleFormatContext::default(), [MyFormat { items: vec!["a", "b", "c"]}]).unwrap(); +/// let formatted = format!(SimpleFormatContext::default(), [MyFormat]).unwrap(); /// -/// assert_eq!("(\n\ttest\n)", formatted.print().as_code()); +/// assert_eq!("1\n\t2\n\t3\n\t4\n", formatted.print().as_code()); /// ``` -pub const fn format_once(closure: T) -> FormatOnce +/// +/// Formatting the same value twice results in a panic. +/// +/// ```panics +/// use rome_formatter::prelude::*; +/// use rome_formatter::{SimpleFormatContext, format, write, Buffer}; +/// use rome_rowan::TextSize; +/// +/// let mut count = 0; +/// +/// let value = format_once(|f| { +/// write!(f, [dynamic_token(&std::format!("Formatted {count}."), TextSize::default())]) +/// }); +/// +/// format!(SimpleFormatContext::default(), [value]).expect("Formatting once works fine"); +/// +/// // Formatting the value more than once panics +/// format!(SimpleFormatContext::default(), [value]); +/// ``` +pub const fn format_once(formatter: T) -> FormatOnce where T: FnOnce(&mut Formatter) -> FormatResult<()>, { FormatOnce { - closure: Cell::new(Some(closure)), - options: PhantomData, + formatter: Cell::new(Some(formatter)), + context: PhantomData, } } pub struct FormatOnce { - closure: Cell>, - options: PhantomData, + formatter: Cell>, + context: PhantomData, } impl Format for FormatOnce where T: FnOnce(&mut Formatter) -> FormatResult<()>, { - fn format(&self, f: &mut Formatter) -> FormatResult<()> { - let closure = self.closure.take().expect("Tried to format once at least twice. This is not allowed. You may want to use format_with or .memoized instead"); + fn fmt(&self, f: &mut Formatter) -> FormatResult<()> { + let formatter = self.formatter.take().expect("Tried to format a `format_once` at least twice. This is not allowed. You may want to use `format_with` or `format.memoized` instead."); - (closure)(f) + (formatter)(f) } } impl std::fmt::Debug for FormatOnce { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - std::write!(f, "FormatOnce([closure])") + f.debug_tuple("FormatOnce").field(&"{{formatter}}").finish() } } /// Builder to join together a sequence of content. /// See [Formatter::join] -pub struct JoinBuilder<'fmt, 'buf, Joiner, O> { +#[must_use = "must eventually call `finish()` on Format builders"] +pub struct JoinBuilder<'fmt, 'buf, Separator, Context> { result: FormatResult<()>, - fmt: &'fmt mut Formatter<'buf, O>, - with: Option, + fmt: &'fmt mut Formatter<'buf, Context>, + with: Option, has_elements: bool, } -impl<'fmt, 'buf, Joiner, Context> JoinBuilder<'fmt, 'buf, Joiner, Context> +impl<'fmt, 'buf, Separator, Context> JoinBuilder<'fmt, 'buf, Separator, Context> where - Joiner: Format, + Separator: Format, { /// Creates a new instance that joins the elements without a separator pub(super) fn new(fmt: &'fmt mut Formatter<'buf, Context>) -> Self { @@ -1476,7 +1441,7 @@ where } /// Creates a new instance that prints the passed separator between every two entries. - pub(super) fn with(fmt: &'fmt mut Formatter<'buf, Context>, with: Joiner) -> Self { + pub(super) fn with_separator(fmt: &'fmt mut Formatter<'buf, Context>, with: Separator) -> Self { Self { result: Ok(()), fmt, @@ -1490,12 +1455,12 @@ where self.result = self.result.and_then(|_| { if let Some(with) = &self.with { if self.has_elements { - with.format(self.fmt)?; + with.fmt(self.fmt)?; } } self.has_elements = true; - entry.format(self.fmt) + entry.fmt(self.fmt) }); self @@ -1522,11 +1487,12 @@ where /// Builder to join together nodes that ensures that nodes separated by empty lines continue /// to be separated by empty lines in the formatted output. -pub struct JoinNodesBuilder<'fmt, 'buf, Separator, O> { +#[must_use = "must eventually call `finish()` on Format builders"] +pub struct JoinNodesBuilder<'fmt, 'buf, Separator, Context> { result: FormatResult<()>, /// The separator to insert between nodes. Either a soft or hard line break separator: Separator, - fmt: &'fmt mut Formatter<'buf, O>, + fmt: &'fmt mut Formatter<'buf, Context>, has_elements: bool, } @@ -1554,7 +1520,7 @@ where if get_lines_before(node) > 1 { write!(f, [empty_line()])?; } else { - write!(f, [&self.separator])?; + self.separator.fmt(f)?; } } @@ -1608,9 +1574,10 @@ pub fn get_lines_before(next_node: &SyntaxNode) -> usize { } /// Builder to fill as many elements as possible on a single line. -pub struct FillBuilder<'fmt, 'buf, O> { +#[must_use = "must eventually call `finish()` on Format builders"] +pub struct FillBuilder<'fmt, 'buf, Context> { result: FormatResult<()>, - fmt: &'fmt mut Formatter<'buf, O>, + fmt: &'fmt mut Formatter<'buf, Context>, /// The separator to use to join the elements separator: FormatElement, @@ -1715,14 +1682,14 @@ impl<'a, Context> BestFitting<'a, Context> { } impl Format for BestFitting<'_, Context> { - fn format(&self, f: &mut Formatter) -> FormatResult<()> { + fn fmt(&self, f: &mut Formatter) -> FormatResult<()> { let mut buffer = VecBuffer::new(f.state_mut()); let variants = self.variants.items(); let mut formatted_variants = Vec::with_capacity(variants.len()); for variant in variants { - write!(buffer, [variant])?; + buffer.write_fmt(Arguments::new(&[*variant]))?; formatted_variants.push(buffer.take()); } @@ -1740,12 +1707,3 @@ impl Format for BestFitting<'_, Context> { Ok(()) } } - -impl std::fmt::Debug for BestFitting<'_, Context> -where - Context: std::fmt::Display + FormatContext + Default, -{ - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - f.debug_tuple("BestFitting").field(&self.variants).finish() - } -} diff --git a/crates/rome_formatter/src/format_extensions.rs b/crates/rome_formatter/src/format_extensions.rs index 4b88151861b..c1059196cc9 100644 --- a/crates/rome_formatter/src/format_extensions.rs +++ b/crates/rome_formatter/src/format_extensions.rs @@ -23,7 +23,7 @@ pub trait FormatOptional { /// struct MyFormat; /// /// impl Format for MyFormat { - /// fn format(&self, f: &mut Formatter) -> FormatResult<()> { + /// fn fmt(&self, f: &mut Formatter) -> FormatResult<()> { /// write!(f, [token("MyToken")]) /// } /// } @@ -62,7 +62,7 @@ impl<'a, With, Context> Format for FormatItemWith<'a, With, Context> where With: Fn(&dyn Format, &mut Formatter) -> FormatResult<()>, { - fn format(&self, f: &mut Formatter) -> FormatResult<()> { + fn fmt(&self, f: &mut Formatter) -> FormatResult<()> { (self.with)(self.inner, f) } } @@ -107,7 +107,7 @@ pub trait MemoizeFormat { /// } /// /// impl Format for MyFormat { - /// fn format(&self, f: &mut Formatter) -> FormatResult<()> { + /// fn fmt(&self, f: &mut Formatter) -> FormatResult<()> { /// let value = self.value.get(); /// self.value.set(value + 1); /// @@ -165,7 +165,7 @@ impl Format for Memoized where F: Format, { - fn format(&self, f: &mut Formatter) -> FormatResult<()> { + fn fmt(&self, f: &mut Formatter) -> FormatResult<()> { // Cached if let Some(memory) = self.memory.borrow().as_ref() { return match memory { diff --git a/crates/rome_formatter/src/formatter.rs b/crates/rome_formatter/src/formatter.rs index 13564a7446e..9e0eb16905b 100644 --- a/crates/rome_formatter/src/formatter.rs +++ b/crates/rome_formatter/src/formatter.rs @@ -5,7 +5,7 @@ use crate::prelude::*; use crate::printed_tokens::PrintedTokens; use crate::{Arguments, Buffer, FormatState, GroupId}; -/// Handles the formatting of a CST and stores the options how the CST should be formatted (user preferences). +/// Handles the formatting of a CST and stores the context how the CST should be formatted (user preferences). /// The formatter is passed to the [Format] implementation of every node in the CST so that they /// can use it to format their children. pub struct Formatter<'buf, Context> { @@ -68,7 +68,7 @@ impl<'buf, Context> Formatter<'buf, Context> { /// use rome_formatter::prelude::*; /// /// let formatted = format!(SimpleFormatContext::default(), [format_with(|f| { - /// f.join_with(format_args!(token(","), space_token())) + /// f.join_with(&format_args!(token(","), space_token())) /// .entry(&token("1")) /// .entry(&token("2")) /// .entry(&token("3")) @@ -88,7 +88,7 @@ impl<'buf, Context> Formatter<'buf, Context> { where Joiner: Format, { - JoinBuilder::with(self, joiner) + JoinBuilder::with_separator(self, joiner) } /// Specialized version of [join_with] for joining SyntaxNodes separated by a space, soft diff --git a/crates/rome_formatter/src/lib.rs b/crates/rome_formatter/src/lib.rs index e3ce51dabf6..14e8a9cb679 100644 --- a/crates/rome_formatter/src/lib.rs +++ b/crates/rome_formatter/src/lib.rs @@ -43,7 +43,7 @@ use crate::prelude::syntax_token_cow_slice; use crate::printed_tokens::PrintedTokens; use crate::printer::{Printer, PrinterOptions}; pub use arguments::{Argument, Arguments}; -pub use buffer::{Buffer, BufferSnapshot, PreambleBuffer, VecBuffer}; +pub use buffer::{Buffer, BufferExtensions, BufferSnapshot, Inspect, PreambleBuffer, VecBuffer}; pub use builders::{ block_indent, comment, empty_element, empty_line, group_elements, hard_line_break, if_group_breaks, if_group_fits_on_line, indent, line_suffix, soft_block_indent, @@ -232,7 +232,7 @@ impl Formatted { Printer::new(self.options.clone()).print(&self.root) } - pub fn print_with_indent(self, indent: u16) -> Printed { + pub fn print_with_indent(&self, indent: u16) -> Printed { Printer::new(self.options.clone()).print_with_indent(&self.root, indent) } @@ -371,7 +371,7 @@ impl From<&SyntaxError> for FormatError { /// struct Paragraph(String); /// /// impl Format for Paragraph { -/// fn format(&self, f: &mut Formatter) -> FormatResult<()> { +/// fn fmt(&self, f: &mut Formatter) -> FormatResult<()> { /// write!(f, [ /// hard_line_break(), /// dynamic_token(&self.0, TextSize::from(0)), @@ -386,16 +386,16 @@ impl From<&SyntaxError> for FormatError { /// assert_eq!("test\n", formatted.print().as_code()) /// ``` pub trait Format { - /// Formats the object - fn format(&self, f: &mut Formatter) -> FormatResult<()>; + /// Formats the object using the given formatter. + fn fmt(&self, f: &mut Formatter) -> FormatResult<()>; } impl Format for &T where T: ?Sized + Format, { - fn format(&self, f: &mut Formatter) -> FormatResult<()> { - Format::format(&**self, f) + fn fmt(&self, f: &mut Formatter) -> FormatResult<()> { + Format::fmt(&**self, f) } } @@ -403,8 +403,8 @@ impl Format for &mut T where T: ?Sized + Format, { - fn format(&self, f: &mut Formatter) -> FormatResult<()> { - Format::format(&**self, f) + fn fmt(&self, f: &mut Formatter) -> FormatResult<()> { + Format::fmt(&**self, f) } } @@ -412,9 +412,9 @@ impl Format for Option where T: Format, { - fn format(&self, f: &mut Formatter) -> FormatResult<()> { + fn fmt(&self, f: &mut Formatter) -> FormatResult<()> { match self { - Some(value) => value.format(f), + Some(value) => value.fmt(f), None => Ok(()), } } @@ -424,9 +424,9 @@ impl Format for SyntaxResult where T: Format, { - fn format(&self, f: &mut Formatter) -> FormatResult<()> { + fn fmt(&self, f: &mut Formatter) -> FormatResult<()> { match self { - Ok(value) => value.format(f), + Ok(value) => value.fmt(f), Err(err) => Err(err.into()), } } @@ -434,7 +434,7 @@ where impl Format for () { #[inline] - fn format(&self, _: &mut Formatter) -> FormatResult<()> { + fn fmt(&self, _: &mut Formatter) -> FormatResult<()> { // Intentionally left empty Ok(()) } @@ -453,7 +453,7 @@ impl Format for () { pub trait FormatRule { type Context; - fn format(item: &T, f: &mut Formatter) -> FormatResult<()>; + fn fmt(item: &T, f: &mut Formatter) -> FormatResult<()>; } /// Trait for an object that formats an object with a specified rule. @@ -525,8 +525,8 @@ where R: FormatRule, { #[inline] - fn format(&self, f: &mut Formatter) -> FormatResult<()> { - R::format(self.item, f) + fn fmt(&self, f: &mut Formatter) -> FormatResult<()> { + R::fmt(self.item, f) } } @@ -565,8 +565,8 @@ where R: FormatRule, { #[inline] - fn format(&self, f: &mut Formatter) -> FormatResult<()> { - R::format(&self.item, f) + fn fmt(&self, f: &mut Formatter) -> FormatResult<()> { + R::fmt(&self.item, f) } } @@ -651,13 +651,13 @@ pub fn write( /// let formatted = format!(SimpleFormatContext::default(), [token("test")]).unwrap(); /// assert_eq!("test", formatted.print().as_code()); /// ``` -pub fn format(options: Context, arguments: Arguments) -> FormatResult +pub fn format(context: Context, arguments: Arguments) -> FormatResult where Context: FormatContext, { - let print_options = options.as_print_options(); - let mut context = FormatState::new(options); - let mut buffer = VecBuffer::with_capacity(arguments.items().len(), &mut context); + let print_options = context.as_print_options(); + let mut state = FormatState::new(context); + let mut buffer = VecBuffer::with_capacity(arguments.items().len(), &mut state); buffer.write_fmt(arguments)?; @@ -749,7 +749,7 @@ where /// It returns a [Formatted] result with a range corresponding to the /// range of the input that was effectively overwritten by the formatter pub fn format_range( - options: Context, + context: Context, root: &SyntaxNode, mut range: TextRange, mut predicate: P, @@ -899,7 +899,7 @@ where // Perform the actual formatting of the root node with // an appropriate indentation level - let formatted = format_sub_tree(options, &FormatRefWithRule::<_, R>::new(common_root))?; + let formatted = format_sub_tree(context, &FormatRefWithRule::<_, R>::new(common_root))?; // This finds the closest marker to the beginning of the source // starting before or at said starting point, and the closest @@ -1048,7 +1048,7 @@ pub fn format_sub_tree< } impl Format for SyntaxTriviaPieceComments { - fn format(&self, f: &mut Formatter) -> FormatResult<()> { + fn fmt(&self, f: &mut Formatter) -> FormatResult<()> { let range = self.text_range(); write!( @@ -1082,8 +1082,8 @@ where Context: fmt::Debug, { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - f.debug_struct("FormatContext") - .field("options", &self.context) + f.debug_struct("FormatState") + .field("context", &self.context) .finish() } } diff --git a/crates/rome_formatter/src/macros.rs b/crates/rome_formatter/src/macros.rs index 738bbf00075..34093d07f4c 100644 --- a/crates/rome_formatter/src/macros.rs +++ b/crates/rome_formatter/src/macros.rs @@ -49,7 +49,7 @@ macro_rules! format_args { /// use rome_formatter::{Buffer, FormatState, SimpleFormatContext, VecBuffer, write}; /// /// fn main() -> FormatResult<()> { -/// let mut state = FormatState::new(SimpleFormatContext::default()); +/// let mut state = FormatState::new(SimpleFormatContext::default()); /// let mut buffer = VecBuffer::new(&mut state); /// write!(&mut buffer, [token("Hello"), space_token()])?; /// write!(&mut buffer, [token("World")])?; @@ -73,6 +73,41 @@ macro_rules! write { }} } +/// Writes formatted data into the given buffer and prints all written elements for a quick and dirty debugging. +/// +/// An example: +/// +/// ```rust +/// use rome_formatter::prelude::*; +/// use rome_formatter::{FormatState, VecBuffer}; +/// +/// let mut state = FormatState::new(SimpleFormatContext::default()); +/// let mut buffer = VecBuffer::new(&mut state); +/// +/// dbg_write!(&mut buffer, [token("Hello")]).unwrap(); +/// // ^-- prints: [src/main.rs:7][0] = StaticToken("Hello") +/// +/// assert_eq!(buffer.into_element(), FormatElement::Token(Token::Static { text: "Hello" })); +/// ``` +/// +/// Note that the macro is intended as debugging tool and therefore you should avoid having +/// uses of it in version control for long periods (other than in tests and similar). Format output +/// from production code is better done with `[write!]` +#[macro_export] +macro_rules! dbg_write { + ($dst:expr, [$($arg:expr),+ $(,)?]) => {{ + let mut count = 0; + let mut inspect = $crate::Inspect::new($dst, |element: &FormatElement| { + std::eprintln!( + "[{}:{}][{}] = {element:#?}", + std::file!(), std::line!(), count + ); + count += 1; + }); + inspect.write_fmt($crate::format_args!($($arg),+)) + }} +} + /// Creates the Format IR for a value. /// /// The first argument `format!` receives is the [FormatContext] that specify how elements must be formatted. @@ -123,9 +158,9 @@ macro_rules! format { /// // Everything fits on a single line /// format_args!( /// token("("), -/// group_elements(format_args![ +/// group_elements(&format_args![ /// token("["), -/// soft_block_indent(format_args![ +/// soft_block_indent(&format_args![ /// token("1,"), /// soft_line_break_or_space(), /// token("2,"), @@ -141,7 +176,7 @@ macro_rules! format { /// format_args!( /// token("("), /// token("["), -/// block_indent(token("1, 2, 3")), +/// block_indent(&token("1, 2, 3")), /// token("]"), /// token(")"), /// ), @@ -149,9 +184,9 @@ macro_rules! format { /// // Breaks after `[` and prints each element on a single line /// format_args!( /// token("("), -/// block_indent(format_args![ +/// block_indent(&format_args![ /// token("["), -/// block_indent(format_args![ +/// block_indent(&format_args![ /// token("1,"), /// hard_line_break(), /// token("2,"), @@ -222,7 +257,7 @@ mod tests { struct TestFormat; impl Format<()> for TestFormat { - fn format(&self, f: &mut Formatter<()>) -> FormatResult<()> { + fn fmt(&self, f: &mut Formatter<()>) -> FormatResult<()> { write!(f, [token("test")]) } } diff --git a/crates/rome_formatter/src/prelude.rs b/crates/rome_formatter/src/prelude.rs index 27cdf13aae8..9c236dd851b 100644 --- a/crates/rome_formatter/src/prelude.rs +++ b/crates/rome_formatter/src/prelude.rs @@ -5,6 +5,6 @@ pub use crate::formatter::Formatter; pub use crate::printer::PrinterOptions; pub use crate::{ - best_fitting, format, format_args, write, Buffer as _, Format, Format as _, FormatError, - FormatResult, FormatRule, FormatWithRule as _, SimpleFormatContext, + best_fitting, dbg_write, format, format_args, write, Buffer as _, BufferExtensions, Format, + Format as _, FormatError, FormatResult, FormatRule, FormatWithRule as _, SimpleFormatContext, }; diff --git a/crates/rome_formatter/src/printer/mod.rs b/crates/rome_formatter/src/printer/mod.rs index 3b8840ebadf..588183d3407 100644 --- a/crates/rome_formatter/src/printer/mod.rs +++ b/crates/rome_formatter/src/printer/mod.rs @@ -562,7 +562,7 @@ impl Default for PrintElementArgs { } /// The Printer uses a stack that emulates recursion. E.g. recursively processing the elements: -/// `indent(concat(string, string))` would result in the following call stack: +/// `indent(&concat(string, string))` would result in the following call stack: /// /// ```plain /// print_element(indent, indent = 0); @@ -937,11 +937,11 @@ mod tests { fn it_tracks_the_indent_for_each_token() { let formatted = format(&format_args!( token("a"), - soft_block_indent(format_args!( + soft_block_indent(&format_args!( token("b"), - soft_block_indent(format_args!( + soft_block_indent(&format_args!( token("c"), - soft_block_indent(format_args!(token("d"), soft_line_break(), token("d"),)), + soft_block_indent(&format_args!(token("d"), soft_line_break(), token("d"),)), token("c"), )), token("b"), @@ -972,7 +972,7 @@ a"#, let result = format_with_options( &format_args![ token("function main() {"), - block_indent(token("let x = `This is a multiline\nstring`;")), + block_indent(&token("let x = `This is a multiline\nstring`;")), token("}"), hard_line_break() ], @@ -1005,9 +1005,9 @@ two lines`, } #[test] fn it_breaks_a_group_if_it_contains_a_hard_line_break() { - let result = format(&group_elements(format_args![ + let result = format(&group_elements(&format_args![ token("a"), - block_indent(token("b")) + block_indent(&token("b")) ])); assert_eq!("a\n b\n", result.as_code()) @@ -1119,15 +1119,15 @@ two lines`, // This one fits on a line by itself, .entry(&format_args!(token("723493294"), token(","))) // fits without breaking - .entry(&group_elements(format_args!( + .entry(&group_elements(&format_args!( token("["), - soft_block_indent(token("5")), + soft_block_indent(&token("5")), token("],") ))) // this one must be printed in expanded mode to fit - .entry(&group_elements(format_args!( + .entry(&group_elements(&format_args!( token("["), - soft_block_indent(token("123456789")), + soft_block_indent(&token("123456789")), token("]"), ))) .finish() @@ -1147,19 +1147,19 @@ two lines`, #[test] fn line_suffix_printed_at_end() { let printed = format(&format_args![ - group_elements(format_args![ + group_elements(&format_args![ token("["), - soft_block_indent(format_with(|f| { + soft_block_indent(&format_with(|f| { f.fill(soft_line_break_or_space()) .entry(&format_args!(token("1"), token(","))) .entry(&format_args!(token("2"), token(","))) - .entry(&format_args!(token("3"), if_group_breaks(token(",")))) + .entry(&format_args!(token("3"), if_group_breaks(&token(",")))) .finish() })), token("]") ]), token(";"), - comment(line_suffix(format_args![ + comment(&line_suffix(&format_args![ space_token(), token("// trailing"), space_token() @@ -1174,17 +1174,17 @@ two lines`, } impl Format<()> for FormatArrayElements<'_> { - fn format(&self, f: &mut Formatter<()>) -> FormatResult<()> { + fn fmt(&self, f: &mut Formatter<()>) -> FormatResult<()> { write!( f, - [group_elements(format_args!( + [group_elements(&format_args!( token("["), - soft_block_indent(format_args!( + soft_block_indent(&format_args!( format_with(|f| f .join_with(format_args!(token(","), soft_line_break_or_space())) .entries(&self.items) .finish()), - if_group_breaks(token(",")), + if_group_breaks(&token(",")), )), token("]") ))] diff --git a/crates/rome_js_formatter/README.md b/crates/rome_js_formatter/README.md index 869b4050244..57ee956b29a 100644 --- a/crates/rome_js_formatter/README.md +++ b/crates/rome_js_formatter/README.md @@ -18,16 +18,17 @@ The foundation of the formatter relies on two pillars: Import the `FormatNode` trait and implement it for your Node. ```rust -use rome_js_formatter::{Format, FormatNode, FormatElement, format_elements, token}; +use rome_js_formatter::prelude::*; +use rome_formatter::{write, format_args}; struct Buzz { blast: String } -impl FormatNode for Buzz { - fn format_fields(&self, formatter: &Formatter) -> FormatResult { +impl Format for Buzz { + fn fmt(&self, f: &mut JsFormatter) -> FormatResult<()> { // implementation goes here - format_elements![token("_"), blast.as_str(), token("_")] + write!(f, [token("Hello"), dynamic_token(&self.blast)]) } } @@ -38,11 +39,28 @@ impl FormatNode for Buzz { 1. if a token is mandatory and the AST has that information, please use that token instead, for example: ```rust - fn format_fields(&self, formatter: &Formatter) -> FormatResult { - let l_paren_yes = &self.l_paren_token()?.format(); // yes - let l_paren_no = toke("("); // no + fn format_fields(node: Node, f: &mut JsFormatter) -> FormatResult<()> { + write!(f, [node.l_paren_token().format()])?; // yes + write!(f, [token("(")])?; // no } ``` - 1. for tokens that are not mandatory, use our helpers - 1. do not attempt to "fix" the code. If you know a token/node is mandatory, return `None` instead +2. for tokens that are not mandatory, use our helpers +3. do not attempt to "fix" the code. If you know a token/node is mandatory, return `None` instead + +## Debugging formatter output + +You can use the `dbg_write!` macro to output the written IR elements to the console (similar to how the `dbg!` macro works). + +```rust +dbg_write!(f, [ + token("hello"), + space_token(), + token("world") +])?; + +// Writes +// [src/main.rs:1][0] = StaticToken("hello") +// [src/main.rs:1][1] = Space +// [src/main.rs:1][0] = StaticToken("world") +``` diff --git a/crates/rome_js_formatter/src/builders.rs b/crates/rome_js_formatter/src/builders.rs index e7a4b076041..fd172569ef8 100644 --- a/crates/rome_js_formatter/src/builders.rs +++ b/crates/rome_js_formatter/src/builders.rs @@ -19,7 +19,7 @@ pub struct FormatTrimmedToken<'a> { } impl Format for FormatTrimmedToken<'_> { - fn format(&self, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(&self, f: &mut JsFormatter) -> FormatResult<()> { let trimmed_range = self.token.text_trimmed_range(); write!(f, [syntax_token_text_slice(self.token, trimmed_range)]) @@ -49,7 +49,7 @@ pub struct FormatLeadingTrivia<'a> { } impl Format for FormatLeadingTrivia<'_> { - fn format(&self, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(&self, f: &mut JsFormatter) -> FormatResult<()> { let snapshot = Formatter::snapshot(f); match write_leading_trivia_pieces( @@ -151,7 +151,7 @@ where Ok(()) }); - write!(buffer, [comment(format_content)])?; + write!(buffer, [comment(&format_content)])?; line_count = 0; trim_mode = TriviaPrintMode::Full; @@ -284,7 +284,7 @@ impl Format for FormatTrailingTriviaPieces where I: Iterator> + Clone, { - fn format(&self, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(&self, f: &mut JsFormatter) -> FormatResult<()> { let pieces = self.pieces.clone(); for piece in pieces { @@ -298,14 +298,14 @@ where write![ f, [ - line_suffix(format_args![space_token(), comment_piece]), + line_suffix(&format_args![space_token(), comment_piece]), expand_parent() ] ] } }); - write!(f, [comment(content)])?; + write!(f, [comment(&content)])?; } } @@ -332,7 +332,7 @@ impl<'a, Node> Format for FormatNodeOrVerbatim<'a, Node> where Node: AstNode + AsFormat<'a>, { - fn format(&self, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(&self, f: &mut JsFormatter) -> FormatResult<()> { let snapshot = Formatter::snapshot(f); match write![f, [self.node.format()]] { @@ -353,24 +353,21 @@ where /// /// This will print the trivia that belong to `token` to `content`; /// `token` is then marked as consumed by the formatter. -pub const fn format_replaced( - token: &JsSyntaxToken, - content: Content, -) -> FormatReplaced { +pub const fn format_replaced<'a, 'content>( + token: &'a JsSyntaxToken, + content: &'content dyn Format, +) -> FormatReplaced<'a, 'content> { FormatReplaced { token, content } } -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct FormatReplaced<'a, Content> { +#[derive(Copy, Clone)] +pub struct FormatReplaced<'a, 'content> { token: &'a JsSyntaxToken, - content: Content, + content: &'content dyn Format, } -impl Format for FormatReplaced<'_, Content> -where - Content: Format, -{ - fn format(&self, f: &mut JsFormatter) -> FormatResult<()> { +impl Format for FormatReplaced<'_, '_> { + fn fmt(&self, f: &mut JsFormatter) -> FormatResult<()> { f.state_mut().track_token(self.token); write!( @@ -409,7 +406,7 @@ pub struct FormatVerbatimNode<'node> { kind: VerbatimKind, } impl Format for FormatVerbatimNode<'_> { - fn format(&self, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(&self, f: &mut JsFormatter) -> FormatResult<()> { for token in self.node.descendants_tokens() { f.state_mut().track_token(&token); } @@ -499,7 +496,7 @@ pub struct FormatUnknownNode<'node> { } impl Format for FormatUnknownNode<'_> { - fn format(&self, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(&self, f: &mut JsFormatter) -> FormatResult<()> { write!( f, [FormatVerbatimNode { @@ -521,7 +518,7 @@ pub struct FormatSuppressedNode<'node> { } impl Format for FormatSuppressedNode<'_> { - fn format(&self, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(&self, f: &mut JsFormatter) -> FormatResult<()> { // Insert a force a line break to ensure the suppression comment is on its own line // and correctly registers as a leading trivia on the opening token of this node write!( @@ -542,11 +539,11 @@ impl Format for FormatSuppressedNode<'_> { /// /// Calling this method is required to correctly handle the comments attached /// to the opening and closing tokens and insert them inside the group block -pub const fn format_delimited<'a, Content>( +pub const fn format_delimited<'a, 'content>( open_token: &'a JsSyntaxToken, - content: Content, + content: &'content dyn Format, close_token: &'a JsSyntaxToken, -) -> FormatDelimited<'a, Content> { +) -> FormatDelimited<'a, 'content> { FormatDelimited { open_token, content, @@ -555,15 +552,15 @@ pub const fn format_delimited<'a, Content>( } } -#[derive(Copy, Clone, Eq, PartialEq, Debug)] -pub struct FormatDelimited<'a, Content> { +#[derive(Copy, Clone)] +pub struct FormatDelimited<'a, 'content> { open_token: &'a JsSyntaxToken, - content: Content, + content: &'content dyn Format, close_token: &'a JsSyntaxToken, mode: DelimitedMode, } -impl<'a, Content> FormatDelimited<'a, Content> { +impl FormatDelimited<'_, '_> { fn with_mode(mut self, mode: DelimitedMode) -> Self { self.mode = mode; self @@ -593,11 +590,8 @@ impl<'a, Content> FormatDelimited<'a, Content> { } } -impl Format for FormatDelimited<'_, Content> -where - Content: Format, -{ - fn format(&self, f: &mut JsFormatter) -> FormatResult<()> { +impl Format for FormatDelimited<'_, '_> { + fn fmt(&self, f: &mut JsFormatter) -> FormatResult<()> { let FormatDelimited { open_token, close_token, @@ -645,7 +639,7 @@ where DelimitedMode::BlockIndent => { write!( f, - [block_indent(format_args![ + [block_indent(&format_args![ open_token_trailing_trivia, content, close_token_leading_trivia ])] @@ -653,7 +647,7 @@ where } DelimitedMode::SoftBlockIndent(_) => write!( f, - [soft_block_indent(format_args![ + [soft_block_indent(&format_args![ open_token_trailing_trivia, content, close_token_leading_trivia ])] @@ -674,7 +668,7 @@ where write!( f, [ - indent(format_once(|f| { + indent(&format_once(|f| { write!(f, [soft_line_break_or_space()])?; f.write_element(content) }),), @@ -693,7 +687,7 @@ where DelimitedMode::BlockIndent => write!(f, [delimited])?, DelimitedMode::SoftBlockIndent(group_id) | DelimitedMode::SoftBlockSpaces(group_id) => { match group_id { - None => write!(f, [group_elements(delimited)])?, + None => write!(f, [group_elements(&delimited)])?, Some(group_id) => write!( f, [group_elements(&delimited).with_group_id(Some(*group_id))] diff --git a/crates/rome_js_formatter/src/cst.rs b/crates/rome_js_formatter/src/cst.rs index 0483e2316c2..1c5741933ea 100644 --- a/crates/rome_js_formatter/src/cst.rs +++ b/crates/rome_js_formatter/src/cst.rs @@ -9,8 +9,8 @@ pub struct FormatJsSyntaxNode; impl rome_formatter::FormatRule for FormatJsSyntaxNode { type Context = JsFormatContext; - fn format(node: &JsSyntaxNode, f: &mut JsFormatter) -> FormatResult<()> { - map_syntax_node!(node.clone(), node => node.format().format(f)) + fn fmt(node: &JsSyntaxNode, f: &mut JsFormatter) -> FormatResult<()> { + map_syntax_node!(node.clone(), node => node.format().fmt(f)) } } diff --git a/crates/rome_js_formatter/src/js/any/array_assignment_pattern_element.rs b/crates/rome_js_formatter/src/js/any/array_assignment_pattern_element.rs index aa6ffdae35f..d5eed91c0d8 100644 --- a/crates/rome_js_formatter/src/js/any/array_assignment_pattern_element.rs +++ b/crates/rome_js_formatter/src/js/any/array_assignment_pattern_element.rs @@ -5,18 +5,18 @@ use crate::prelude::*; use rome_js_syntax::JsAnyArrayAssignmentPatternElement; impl FormatRule for FormatJsAnyArrayAssignmentPatternElement { type Context = JsFormatContext; - fn format(node: &JsAnyArrayAssignmentPatternElement, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &JsAnyArrayAssignmentPatternElement, f: &mut JsFormatter) -> FormatResult<()> { match node { JsAnyArrayAssignmentPatternElement::JsAssignmentWithDefault(node) => { - node.format().format(f) + node.format().fmt(f) } JsAnyArrayAssignmentPatternElement::JsAnyAssignmentPattern(node) => { - node.format().format(f) + node.format().fmt(f) } JsAnyArrayAssignmentPatternElement::JsArrayAssignmentPatternRestElement(node) => { - node.format().format(f) + node.format().fmt(f) } - JsAnyArrayAssignmentPatternElement::JsArrayHole(node) => node.format().format(f), + JsAnyArrayAssignmentPatternElement::JsArrayHole(node) => node.format().fmt(f), } } } diff --git a/crates/rome_js_formatter/src/js/any/array_binding_pattern_element.rs b/crates/rome_js_formatter/src/js/any/array_binding_pattern_element.rs index 4f1447371bc..f81920be54a 100644 --- a/crates/rome_js_formatter/src/js/any/array_binding_pattern_element.rs +++ b/crates/rome_js_formatter/src/js/any/array_binding_pattern_element.rs @@ -5,15 +5,15 @@ use crate::prelude::*; use rome_js_syntax::JsAnyArrayBindingPatternElement; impl FormatRule for FormatJsAnyArrayBindingPatternElement { type Context = JsFormatContext; - fn format(node: &JsAnyArrayBindingPatternElement, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &JsAnyArrayBindingPatternElement, f: &mut JsFormatter) -> FormatResult<()> { match node { - JsAnyArrayBindingPatternElement::JsArrayHole(node) => node.format().format(f), - JsAnyArrayBindingPatternElement::JsAnyBindingPattern(node) => node.format().format(f), + JsAnyArrayBindingPatternElement::JsArrayHole(node) => node.format().fmt(f), + JsAnyArrayBindingPatternElement::JsAnyBindingPattern(node) => node.format().fmt(f), JsAnyArrayBindingPatternElement::JsBindingPatternWithDefault(node) => { - node.format().format(f) + node.format().fmt(f) } JsAnyArrayBindingPatternElement::JsArrayBindingPatternRestElement(node) => { - node.format().format(f) + node.format().fmt(f) } } } diff --git a/crates/rome_js_formatter/src/js/any/array_element.rs b/crates/rome_js_formatter/src/js/any/array_element.rs index 8375813819f..4a88be83639 100644 --- a/crates/rome_js_formatter/src/js/any/array_element.rs +++ b/crates/rome_js_formatter/src/js/any/array_element.rs @@ -5,11 +5,11 @@ use crate::prelude::*; use rome_js_syntax::JsAnyArrayElement; impl FormatRule for FormatJsAnyArrayElement { type Context = JsFormatContext; - fn format(node: &JsAnyArrayElement, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &JsAnyArrayElement, f: &mut JsFormatter) -> FormatResult<()> { match node { - JsAnyArrayElement::JsAnyExpression(node) => node.format().format(f), - JsAnyArrayElement::JsSpread(node) => node.format().format(f), - JsAnyArrayElement::JsArrayHole(node) => node.format().format(f), + JsAnyArrayElement::JsAnyExpression(node) => node.format().fmt(f), + JsAnyArrayElement::JsSpread(node) => node.format().fmt(f), + JsAnyArrayElement::JsArrayHole(node) => node.format().fmt(f), } } } diff --git a/crates/rome_js_formatter/src/js/any/arrow_function_parameters.rs b/crates/rome_js_formatter/src/js/any/arrow_function_parameters.rs index 1e35a1af7dd..7cd5b210610 100644 --- a/crates/rome_js_formatter/src/js/any/arrow_function_parameters.rs +++ b/crates/rome_js_formatter/src/js/any/arrow_function_parameters.rs @@ -5,10 +5,10 @@ use crate::prelude::*; use rome_js_syntax::JsAnyArrowFunctionParameters; impl FormatRule for FormatJsAnyArrowFunctionParameters { type Context = JsFormatContext; - fn format(node: &JsAnyArrowFunctionParameters, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &JsAnyArrowFunctionParameters, f: &mut JsFormatter) -> FormatResult<()> { match node { - JsAnyArrowFunctionParameters::JsParameters(node) => node.format().format(f), - JsAnyArrowFunctionParameters::JsAnyBinding(node) => node.format().format(f), + JsAnyArrowFunctionParameters::JsParameters(node) => node.format().fmt(f), + JsAnyArrowFunctionParameters::JsAnyBinding(node) => node.format().fmt(f), } } } diff --git a/crates/rome_js_formatter/src/js/any/assignment.rs b/crates/rome_js_formatter/src/js/any/assignment.rs index 7eaf59c567b..f0f3f0af8f6 100644 --- a/crates/rome_js_formatter/src/js/any/assignment.rs +++ b/crates/rome_js_formatter/src/js/any/assignment.rs @@ -5,16 +5,16 @@ use crate::prelude::*; use rome_js_syntax::JsAnyAssignment; impl FormatRule for FormatJsAnyAssignment { type Context = JsFormatContext; - fn format(node: &JsAnyAssignment, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &JsAnyAssignment, f: &mut JsFormatter) -> FormatResult<()> { match node { - JsAnyAssignment::JsIdentifierAssignment(node) => node.format().format(f), - JsAnyAssignment::JsStaticMemberAssignment(node) => node.format().format(f), - JsAnyAssignment::JsComputedMemberAssignment(node) => node.format().format(f), - JsAnyAssignment::JsParenthesizedAssignment(node) => node.format().format(f), - JsAnyAssignment::TsNonNullAssertionAssignment(node) => node.format().format(f), - JsAnyAssignment::TsAsAssignment(node) => node.format().format(f), - JsAnyAssignment::TsTypeAssertionAssignment(node) => node.format().format(f), - JsAnyAssignment::JsUnknownAssignment(node) => node.format().format(f), + JsAnyAssignment::JsIdentifierAssignment(node) => node.format().fmt(f), + JsAnyAssignment::JsStaticMemberAssignment(node) => node.format().fmt(f), + JsAnyAssignment::JsComputedMemberAssignment(node) => node.format().fmt(f), + JsAnyAssignment::JsParenthesizedAssignment(node) => node.format().fmt(f), + JsAnyAssignment::TsNonNullAssertionAssignment(node) => node.format().fmt(f), + JsAnyAssignment::TsAsAssignment(node) => node.format().fmt(f), + JsAnyAssignment::TsTypeAssertionAssignment(node) => node.format().fmt(f), + JsAnyAssignment::JsUnknownAssignment(node) => node.format().fmt(f), } } } diff --git a/crates/rome_js_formatter/src/js/any/assignment_pattern.rs b/crates/rome_js_formatter/src/js/any/assignment_pattern.rs index d9d4f542bd8..4a980764431 100644 --- a/crates/rome_js_formatter/src/js/any/assignment_pattern.rs +++ b/crates/rome_js_formatter/src/js/any/assignment_pattern.rs @@ -5,11 +5,11 @@ use crate::prelude::*; use rome_js_syntax::JsAnyAssignmentPattern; impl FormatRule for FormatJsAnyAssignmentPattern { type Context = JsFormatContext; - fn format(node: &JsAnyAssignmentPattern, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &JsAnyAssignmentPattern, f: &mut JsFormatter) -> FormatResult<()> { match node { - JsAnyAssignmentPattern::JsAnyAssignment(node) => node.format().format(f), - JsAnyAssignmentPattern::JsArrayAssignmentPattern(node) => node.format().format(f), - JsAnyAssignmentPattern::JsObjectAssignmentPattern(node) => node.format().format(f), + JsAnyAssignmentPattern::JsAnyAssignment(node) => node.format().fmt(f), + JsAnyAssignmentPattern::JsArrayAssignmentPattern(node) => node.format().fmt(f), + JsAnyAssignmentPattern::JsObjectAssignmentPattern(node) => node.format().fmt(f), } } } diff --git a/crates/rome_js_formatter/src/js/any/binding.rs b/crates/rome_js_formatter/src/js/any/binding.rs index dd9b93cd3ca..1bb654f3aa2 100644 --- a/crates/rome_js_formatter/src/js/any/binding.rs +++ b/crates/rome_js_formatter/src/js/any/binding.rs @@ -5,10 +5,10 @@ use crate::prelude::*; use rome_js_syntax::JsAnyBinding; impl FormatRule for FormatJsAnyBinding { type Context = JsFormatContext; - fn format(node: &JsAnyBinding, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &JsAnyBinding, f: &mut JsFormatter) -> FormatResult<()> { match node { - JsAnyBinding::JsIdentifierBinding(node) => node.format().format(f), - JsAnyBinding::JsUnknownBinding(node) => node.format().format(f), + JsAnyBinding::JsIdentifierBinding(node) => node.format().fmt(f), + JsAnyBinding::JsUnknownBinding(node) => node.format().fmt(f), } } } diff --git a/crates/rome_js_formatter/src/js/any/binding_pattern.rs b/crates/rome_js_formatter/src/js/any/binding_pattern.rs index 684fc410e55..78053569648 100644 --- a/crates/rome_js_formatter/src/js/any/binding_pattern.rs +++ b/crates/rome_js_formatter/src/js/any/binding_pattern.rs @@ -5,11 +5,11 @@ use crate::prelude::*; use rome_js_syntax::JsAnyBindingPattern; impl FormatRule for FormatJsAnyBindingPattern { type Context = JsFormatContext; - fn format(node: &JsAnyBindingPattern, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &JsAnyBindingPattern, f: &mut JsFormatter) -> FormatResult<()> { match node { - JsAnyBindingPattern::JsAnyBinding(node) => node.format().format(f), - JsAnyBindingPattern::JsArrayBindingPattern(node) => node.format().format(f), - JsAnyBindingPattern::JsObjectBindingPattern(node) => node.format().format(f), + JsAnyBindingPattern::JsAnyBinding(node) => node.format().fmt(f), + JsAnyBindingPattern::JsArrayBindingPattern(node) => node.format().fmt(f), + JsAnyBindingPattern::JsObjectBindingPattern(node) => node.format().fmt(f), } } } diff --git a/crates/rome_js_formatter/src/js/any/call_argument.rs b/crates/rome_js_formatter/src/js/any/call_argument.rs index 1bf6bd8e5b2..ee2bd215aff 100644 --- a/crates/rome_js_formatter/src/js/any/call_argument.rs +++ b/crates/rome_js_formatter/src/js/any/call_argument.rs @@ -5,10 +5,10 @@ use crate::prelude::*; use rome_js_syntax::JsAnyCallArgument; impl FormatRule for FormatJsAnyCallArgument { type Context = JsFormatContext; - fn format(node: &JsAnyCallArgument, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &JsAnyCallArgument, f: &mut JsFormatter) -> FormatResult<()> { match node { - JsAnyCallArgument::JsAnyExpression(node) => node.format().format(f), - JsAnyCallArgument::JsSpread(node) => node.format().format(f), + JsAnyCallArgument::JsAnyExpression(node) => node.format().fmt(f), + JsAnyCallArgument::JsSpread(node) => node.format().fmt(f), } } } diff --git a/crates/rome_js_formatter/src/js/any/class.rs b/crates/rome_js_formatter/src/js/any/class.rs index b90a319271c..ab5ebcf7a21 100644 --- a/crates/rome_js_formatter/src/js/any/class.rs +++ b/crates/rome_js_formatter/src/js/any/class.rs @@ -9,7 +9,7 @@ use rome_rowan::AstNode; impl FormatRule for FormatJsAnyClass { type Context = JsFormatContext; - fn format(node: &JsAnyClass, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &JsAnyClass, f: &mut JsFormatter) -> FormatResult<()> { let abstract_token = node.abstract_token(); let id = node.id(); let extends = node.extends_clause(); diff --git a/crates/rome_js_formatter/src/js/any/class_member.rs b/crates/rome_js_formatter/src/js/any/class_member.rs index bf276048b65..f5aa94654bc 100644 --- a/crates/rome_js_formatter/src/js/any/class_member.rs +++ b/crates/rome_js_formatter/src/js/any/class_member.rs @@ -5,24 +5,22 @@ use crate::prelude::*; use rome_js_syntax::JsAnyClassMember; impl FormatRule for FormatJsAnyClassMember { type Context = JsFormatContext; - fn format(node: &JsAnyClassMember, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &JsAnyClassMember, f: &mut JsFormatter) -> FormatResult<()> { match node { - JsAnyClassMember::JsConstructorClassMember(node) => node.format().format(f), - JsAnyClassMember::JsStaticInitializationBlockClassMember(node) => { - node.format().format(f) - } - JsAnyClassMember::JsPropertyClassMember(node) => node.format().format(f), - JsAnyClassMember::JsMethodClassMember(node) => node.format().format(f), - JsAnyClassMember::JsGetterClassMember(node) => node.format().format(f), - JsAnyClassMember::JsSetterClassMember(node) => node.format().format(f), - JsAnyClassMember::TsConstructorSignatureClassMember(node) => node.format().format(f), - JsAnyClassMember::TsPropertySignatureClassMember(node) => node.format().format(f), - JsAnyClassMember::TsMethodSignatureClassMember(node) => node.format().format(f), - JsAnyClassMember::TsGetterSignatureClassMember(node) => node.format().format(f), - JsAnyClassMember::TsSetterSignatureClassMember(node) => node.format().format(f), - JsAnyClassMember::TsIndexSignatureClassMember(node) => node.format().format(f), - JsAnyClassMember::JsEmptyClassMember(node) => node.format().format(f), - JsAnyClassMember::JsUnknownMember(node) => node.format().format(f), + JsAnyClassMember::JsConstructorClassMember(node) => node.format().fmt(f), + JsAnyClassMember::JsStaticInitializationBlockClassMember(node) => node.format().fmt(f), + JsAnyClassMember::JsPropertyClassMember(node) => node.format().fmt(f), + JsAnyClassMember::JsMethodClassMember(node) => node.format().fmt(f), + JsAnyClassMember::JsGetterClassMember(node) => node.format().fmt(f), + JsAnyClassMember::JsSetterClassMember(node) => node.format().fmt(f), + JsAnyClassMember::TsConstructorSignatureClassMember(node) => node.format().fmt(f), + JsAnyClassMember::TsPropertySignatureClassMember(node) => node.format().fmt(f), + JsAnyClassMember::TsMethodSignatureClassMember(node) => node.format().fmt(f), + JsAnyClassMember::TsGetterSignatureClassMember(node) => node.format().fmt(f), + JsAnyClassMember::TsSetterSignatureClassMember(node) => node.format().fmt(f), + JsAnyClassMember::TsIndexSignatureClassMember(node) => node.format().fmt(f), + JsAnyClassMember::JsEmptyClassMember(node) => node.format().fmt(f), + JsAnyClassMember::JsUnknownMember(node) => node.format().fmt(f), } } } diff --git a/crates/rome_js_formatter/src/js/any/class_member_name.rs b/crates/rome_js_formatter/src/js/any/class_member_name.rs index fdd1d7f44a5..89eb974a946 100644 --- a/crates/rome_js_formatter/src/js/any/class_member_name.rs +++ b/crates/rome_js_formatter/src/js/any/class_member_name.rs @@ -5,11 +5,11 @@ use crate::prelude::*; use rome_js_syntax::JsAnyClassMemberName; impl FormatRule for FormatJsAnyClassMemberName { type Context = JsFormatContext; - fn format(node: &JsAnyClassMemberName, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &JsAnyClassMemberName, f: &mut JsFormatter) -> FormatResult<()> { match node { - JsAnyClassMemberName::JsLiteralMemberName(node) => node.format().format(f), - JsAnyClassMemberName::JsComputedMemberName(node) => node.format().format(f), - JsAnyClassMemberName::JsPrivateClassMemberName(node) => node.format().format(f), + JsAnyClassMemberName::JsLiteralMemberName(node) => node.format().fmt(f), + JsAnyClassMemberName::JsComputedMemberName(node) => node.format().fmt(f), + JsAnyClassMemberName::JsPrivateClassMemberName(node) => node.format().fmt(f), } } } diff --git a/crates/rome_js_formatter/src/js/any/constructor_parameter.rs b/crates/rome_js_formatter/src/js/any/constructor_parameter.rs index 57d2384afd8..53ae4c6998e 100644 --- a/crates/rome_js_formatter/src/js/any/constructor_parameter.rs +++ b/crates/rome_js_formatter/src/js/any/constructor_parameter.rs @@ -5,11 +5,11 @@ use crate::prelude::*; use rome_js_syntax::JsAnyConstructorParameter; impl FormatRule for FormatJsAnyConstructorParameter { type Context = JsFormatContext; - fn format(node: &JsAnyConstructorParameter, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &JsAnyConstructorParameter, f: &mut JsFormatter) -> FormatResult<()> { match node { - JsAnyConstructorParameter::JsAnyFormalParameter(node) => node.format().format(f), - JsAnyConstructorParameter::JsRestParameter(node) => node.format().format(f), - JsAnyConstructorParameter::TsPropertyParameter(node) => node.format().format(f), + JsAnyConstructorParameter::JsAnyFormalParameter(node) => node.format().fmt(f), + JsAnyConstructorParameter::JsRestParameter(node) => node.format().fmt(f), + JsAnyConstructorParameter::TsPropertyParameter(node) => node.format().fmt(f), } } } diff --git a/crates/rome_js_formatter/src/js/any/declaration.rs b/crates/rome_js_formatter/src/js/any/declaration.rs index b7f9fe014a2..e256db1c09a 100644 --- a/crates/rome_js_formatter/src/js/any/declaration.rs +++ b/crates/rome_js_formatter/src/js/any/declaration.rs @@ -5,19 +5,19 @@ use crate::prelude::*; use rome_js_syntax::JsAnyDeclaration; impl FormatRule for FormatJsAnyDeclaration { type Context = JsFormatContext; - fn format(node: &JsAnyDeclaration, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &JsAnyDeclaration, f: &mut JsFormatter) -> FormatResult<()> { match node { - JsAnyDeclaration::JsClassDeclaration(node) => node.format().format(f), - JsAnyDeclaration::JsFunctionDeclaration(node) => node.format().format(f), - JsAnyDeclaration::JsVariableDeclaration(node) => node.format().format(f), - JsAnyDeclaration::TsEnumDeclaration(node) => node.format().format(f), - JsAnyDeclaration::TsTypeAliasDeclaration(node) => node.format().format(f), - JsAnyDeclaration::TsInterfaceDeclaration(node) => node.format().format(f), - JsAnyDeclaration::TsDeclareFunctionDeclaration(node) => node.format().format(f), - JsAnyDeclaration::TsModuleDeclaration(node) => node.format().format(f), - JsAnyDeclaration::TsExternalModuleDeclaration(node) => node.format().format(f), - JsAnyDeclaration::TsGlobalDeclaration(node) => node.format().format(f), - JsAnyDeclaration::TsImportEqualsDeclaration(node) => node.format().format(f), + JsAnyDeclaration::JsClassDeclaration(node) => node.format().fmt(f), + JsAnyDeclaration::JsFunctionDeclaration(node) => node.format().fmt(f), + JsAnyDeclaration::JsVariableDeclaration(node) => node.format().fmt(f), + JsAnyDeclaration::TsEnumDeclaration(node) => node.format().fmt(f), + JsAnyDeclaration::TsTypeAliasDeclaration(node) => node.format().fmt(f), + JsAnyDeclaration::TsInterfaceDeclaration(node) => node.format().fmt(f), + JsAnyDeclaration::TsDeclareFunctionDeclaration(node) => node.format().fmt(f), + JsAnyDeclaration::TsModuleDeclaration(node) => node.format().fmt(f), + JsAnyDeclaration::TsExternalModuleDeclaration(node) => node.format().fmt(f), + JsAnyDeclaration::TsGlobalDeclaration(node) => node.format().fmt(f), + JsAnyDeclaration::TsImportEqualsDeclaration(node) => node.format().fmt(f), } } } diff --git a/crates/rome_js_formatter/src/js/any/declaration_clause.rs b/crates/rome_js_formatter/src/js/any/declaration_clause.rs index 5d64deb46b1..b23c0c27ce3 100644 --- a/crates/rome_js_formatter/src/js/any/declaration_clause.rs +++ b/crates/rome_js_formatter/src/js/any/declaration_clause.rs @@ -5,19 +5,19 @@ use crate::prelude::*; use rome_js_syntax::JsAnyDeclarationClause; impl FormatRule for FormatJsAnyDeclarationClause { type Context = JsFormatContext; - fn format(node: &JsAnyDeclarationClause, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &JsAnyDeclarationClause, f: &mut JsFormatter) -> FormatResult<()> { match node { - JsAnyDeclarationClause::JsClassDeclaration(node) => node.format().format(f), - JsAnyDeclarationClause::JsFunctionDeclaration(node) => node.format().format(f), - JsAnyDeclarationClause::JsVariableDeclarationClause(node) => node.format().format(f), - JsAnyDeclarationClause::TsEnumDeclaration(node) => node.format().format(f), - JsAnyDeclarationClause::TsTypeAliasDeclaration(node) => node.format().format(f), - JsAnyDeclarationClause::TsInterfaceDeclaration(node) => node.format().format(f), - JsAnyDeclarationClause::TsDeclareFunctionDeclaration(node) => node.format().format(f), - JsAnyDeclarationClause::TsModuleDeclaration(node) => node.format().format(f), - JsAnyDeclarationClause::TsExternalModuleDeclaration(node) => node.format().format(f), - JsAnyDeclarationClause::TsGlobalDeclaration(node) => node.format().format(f), - JsAnyDeclarationClause::TsImportEqualsDeclaration(node) => node.format().format(f), + JsAnyDeclarationClause::JsClassDeclaration(node) => node.format().fmt(f), + JsAnyDeclarationClause::JsFunctionDeclaration(node) => node.format().fmt(f), + JsAnyDeclarationClause::JsVariableDeclarationClause(node) => node.format().fmt(f), + JsAnyDeclarationClause::TsEnumDeclaration(node) => node.format().fmt(f), + JsAnyDeclarationClause::TsTypeAliasDeclaration(node) => node.format().fmt(f), + JsAnyDeclarationClause::TsInterfaceDeclaration(node) => node.format().fmt(f), + JsAnyDeclarationClause::TsDeclareFunctionDeclaration(node) => node.format().fmt(f), + JsAnyDeclarationClause::TsModuleDeclaration(node) => node.format().fmt(f), + JsAnyDeclarationClause::TsExternalModuleDeclaration(node) => node.format().fmt(f), + JsAnyDeclarationClause::TsGlobalDeclaration(node) => node.format().fmt(f), + JsAnyDeclarationClause::TsImportEqualsDeclaration(node) => node.format().fmt(f), } } } diff --git a/crates/rome_js_formatter/src/js/any/export_clause.rs b/crates/rome_js_formatter/src/js/any/export_clause.rs index 2d599e7b856..e87aaff182e 100644 --- a/crates/rome_js_formatter/src/js/any/export_clause.rs +++ b/crates/rome_js_formatter/src/js/any/export_clause.rs @@ -5,17 +5,17 @@ use crate::prelude::*; use rome_js_syntax::JsAnyExportClause; impl FormatRule for FormatJsAnyExportClause { type Context = JsFormatContext; - fn format(node: &JsAnyExportClause, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &JsAnyExportClause, f: &mut JsFormatter) -> FormatResult<()> { match node { - JsAnyExportClause::JsExportDefaultDeclarationClause(node) => node.format().format(f), - JsAnyExportClause::JsExportDefaultExpressionClause(node) => node.format().format(f), - JsAnyExportClause::JsExportNamedClause(node) => node.format().format(f), - JsAnyExportClause::JsExportFromClause(node) => node.format().format(f), - JsAnyExportClause::JsExportNamedFromClause(node) => node.format().format(f), - JsAnyExportClause::JsAnyDeclarationClause(node) => node.format().format(f), - JsAnyExportClause::TsExportAsNamespaceClause(node) => node.format().format(f), - JsAnyExportClause::TsExportAssignmentClause(node) => node.format().format(f), - JsAnyExportClause::TsExportDeclareClause(node) => node.format().format(f), + JsAnyExportClause::JsExportDefaultDeclarationClause(node) => node.format().fmt(f), + JsAnyExportClause::JsExportDefaultExpressionClause(node) => node.format().fmt(f), + JsAnyExportClause::JsExportNamedClause(node) => node.format().fmt(f), + JsAnyExportClause::JsExportFromClause(node) => node.format().fmt(f), + JsAnyExportClause::JsExportNamedFromClause(node) => node.format().fmt(f), + JsAnyExportClause::JsAnyDeclarationClause(node) => node.format().fmt(f), + JsAnyExportClause::TsExportAsNamespaceClause(node) => node.format().fmt(f), + JsAnyExportClause::TsExportAssignmentClause(node) => node.format().fmt(f), + JsAnyExportClause::TsExportDeclareClause(node) => node.format().fmt(f), } } } diff --git a/crates/rome_js_formatter/src/js/any/export_default_declaration.rs b/crates/rome_js_formatter/src/js/any/export_default_declaration.rs index fc3761b324d..06b107a0afe 100644 --- a/crates/rome_js_formatter/src/js/any/export_default_declaration.rs +++ b/crates/rome_js_formatter/src/js/any/export_default_declaration.rs @@ -5,18 +5,18 @@ use crate::prelude::*; use rome_js_syntax::JsAnyExportDefaultDeclaration; impl FormatRule for FormatJsAnyExportDefaultDeclaration { type Context = JsFormatContext; - fn format(node: &JsAnyExportDefaultDeclaration, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &JsAnyExportDefaultDeclaration, f: &mut JsFormatter) -> FormatResult<()> { match node { JsAnyExportDefaultDeclaration::JsClassExportDefaultDeclaration(node) => { - node.format().format(f) + node.format().fmt(f) } JsAnyExportDefaultDeclaration::JsFunctionExportDefaultDeclaration(node) => { - node.format().format(f) + node.format().fmt(f) } JsAnyExportDefaultDeclaration::TsDeclareFunctionDeclaration(node) => { - node.format().format(f) + node.format().fmt(f) } - JsAnyExportDefaultDeclaration::TsInterfaceDeclaration(node) => node.format().format(f), + JsAnyExportDefaultDeclaration::TsInterfaceDeclaration(node) => node.format().fmt(f), } } } diff --git a/crates/rome_js_formatter/src/js/any/export_named_specifier.rs b/crates/rome_js_formatter/src/js/any/export_named_specifier.rs index f7bc1daed0a..061cc62a05e 100644 --- a/crates/rome_js_formatter/src/js/any/export_named_specifier.rs +++ b/crates/rome_js_formatter/src/js/any/export_named_specifier.rs @@ -5,12 +5,12 @@ use crate::prelude::*; use rome_js_syntax::JsAnyExportNamedSpecifier; impl FormatRule for FormatJsAnyExportNamedSpecifier { type Context = JsFormatContext; - fn format(node: &JsAnyExportNamedSpecifier, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &JsAnyExportNamedSpecifier, f: &mut JsFormatter) -> FormatResult<()> { match node { JsAnyExportNamedSpecifier::JsExportNamedShorthandSpecifier(node) => { - node.format().format(f) + node.format().fmt(f) } - JsAnyExportNamedSpecifier::JsExportNamedSpecifier(node) => node.format().format(f), + JsAnyExportNamedSpecifier::JsExportNamedSpecifier(node) => node.format().fmt(f), } } } diff --git a/crates/rome_js_formatter/src/js/any/expression.rs b/crates/rome_js_formatter/src/js/any/expression.rs index 8c0823a6c49..3e23ccbd0ab 100644 --- a/crates/rome_js_formatter/src/js/any/expression.rs +++ b/crates/rome_js_formatter/src/js/any/expression.rs @@ -5,43 +5,43 @@ use crate::prelude::*; use rome_js_syntax::JsAnyExpression; impl FormatRule for FormatJsAnyExpression { type Context = JsFormatContext; - fn format(node: &JsAnyExpression, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &JsAnyExpression, f: &mut JsFormatter) -> FormatResult<()> { match node { - JsAnyExpression::JsAnyLiteralExpression(node) => node.format().format(f), - JsAnyExpression::ImportMeta(node) => node.format().format(f), - JsAnyExpression::JsArrayExpression(node) => node.format().format(f), - JsAnyExpression::JsArrowFunctionExpression(node) => node.format().format(f), - JsAnyExpression::JsAssignmentExpression(node) => node.format().format(f), - JsAnyExpression::JsAwaitExpression(node) => node.format().format(f), - JsAnyExpression::JsBinaryExpression(node) => node.format().format(f), - JsAnyExpression::JsCallExpression(node) => node.format().format(f), - JsAnyExpression::JsClassExpression(node) => node.format().format(f), - JsAnyExpression::JsComputedMemberExpression(node) => node.format().format(f), - JsAnyExpression::JsConditionalExpression(node) => node.format().format(f), - JsAnyExpression::JsFunctionExpression(node) => node.format().format(f), - JsAnyExpression::JsIdentifierExpression(node) => node.format().format(f), - JsAnyExpression::JsImportCallExpression(node) => node.format().format(f), - JsAnyExpression::JsInExpression(node) => node.format().format(f), - JsAnyExpression::JsInstanceofExpression(node) => node.format().format(f), - JsAnyExpression::JsLogicalExpression(node) => node.format().format(f), - JsAnyExpression::JsNewExpression(node) => node.format().format(f), - JsAnyExpression::JsObjectExpression(node) => node.format().format(f), - JsAnyExpression::JsParenthesizedExpression(node) => node.format().format(f), - JsAnyExpression::JsPostUpdateExpression(node) => node.format().format(f), - JsAnyExpression::JsPreUpdateExpression(node) => node.format().format(f), - JsAnyExpression::JsSequenceExpression(node) => node.format().format(f), - JsAnyExpression::JsStaticMemberExpression(node) => node.format().format(f), - JsAnyExpression::JsSuperExpression(node) => node.format().format(f), - JsAnyExpression::JsThisExpression(node) => node.format().format(f), - JsAnyExpression::JsUnaryExpression(node) => node.format().format(f), - JsAnyExpression::JsUnknownExpression(node) => node.format().format(f), - JsAnyExpression::JsYieldExpression(node) => node.format().format(f), - JsAnyExpression::NewTarget(node) => node.format().format(f), - JsAnyExpression::JsTemplate(node) => node.format().format(f), - JsAnyExpression::TsTypeAssertionExpression(node) => node.format().format(f), - JsAnyExpression::TsAsExpression(node) => node.format().format(f), - JsAnyExpression::TsNonNullAssertionExpression(node) => node.format().format(f), - JsAnyExpression::JsxTagExpression(node) => node.format().format(f), + JsAnyExpression::JsAnyLiteralExpression(node) => node.format().fmt(f), + JsAnyExpression::ImportMeta(node) => node.format().fmt(f), + JsAnyExpression::JsArrayExpression(node) => node.format().fmt(f), + JsAnyExpression::JsArrowFunctionExpression(node) => node.format().fmt(f), + JsAnyExpression::JsAssignmentExpression(node) => node.format().fmt(f), + JsAnyExpression::JsAwaitExpression(node) => node.format().fmt(f), + JsAnyExpression::JsBinaryExpression(node) => node.format().fmt(f), + JsAnyExpression::JsCallExpression(node) => node.format().fmt(f), + JsAnyExpression::JsClassExpression(node) => node.format().fmt(f), + JsAnyExpression::JsComputedMemberExpression(node) => node.format().fmt(f), + JsAnyExpression::JsConditionalExpression(node) => node.format().fmt(f), + JsAnyExpression::JsFunctionExpression(node) => node.format().fmt(f), + JsAnyExpression::JsIdentifierExpression(node) => node.format().fmt(f), + JsAnyExpression::JsImportCallExpression(node) => node.format().fmt(f), + JsAnyExpression::JsInExpression(node) => node.format().fmt(f), + JsAnyExpression::JsInstanceofExpression(node) => node.format().fmt(f), + JsAnyExpression::JsLogicalExpression(node) => node.format().fmt(f), + JsAnyExpression::JsNewExpression(node) => node.format().fmt(f), + JsAnyExpression::JsObjectExpression(node) => node.format().fmt(f), + JsAnyExpression::JsParenthesizedExpression(node) => node.format().fmt(f), + JsAnyExpression::JsPostUpdateExpression(node) => node.format().fmt(f), + JsAnyExpression::JsPreUpdateExpression(node) => node.format().fmt(f), + JsAnyExpression::JsSequenceExpression(node) => node.format().fmt(f), + JsAnyExpression::JsStaticMemberExpression(node) => node.format().fmt(f), + JsAnyExpression::JsSuperExpression(node) => node.format().fmt(f), + JsAnyExpression::JsThisExpression(node) => node.format().fmt(f), + JsAnyExpression::JsUnaryExpression(node) => node.format().fmt(f), + JsAnyExpression::JsUnknownExpression(node) => node.format().fmt(f), + JsAnyExpression::JsYieldExpression(node) => node.format().fmt(f), + JsAnyExpression::NewTarget(node) => node.format().fmt(f), + JsAnyExpression::JsTemplate(node) => node.format().fmt(f), + JsAnyExpression::TsTypeAssertionExpression(node) => node.format().fmt(f), + JsAnyExpression::TsAsExpression(node) => node.format().fmt(f), + JsAnyExpression::TsNonNullAssertionExpression(node) => node.format().fmt(f), + JsAnyExpression::JsxTagExpression(node) => node.format().fmt(f), } } } diff --git a/crates/rome_js_formatter/src/js/any/for_in_or_of_initializer.rs b/crates/rome_js_formatter/src/js/any/for_in_or_of_initializer.rs index df855df25c6..8870f4f43cc 100644 --- a/crates/rome_js_formatter/src/js/any/for_in_or_of_initializer.rs +++ b/crates/rome_js_formatter/src/js/any/for_in_or_of_initializer.rs @@ -5,10 +5,10 @@ use crate::prelude::*; use rome_js_syntax::JsAnyForInOrOfInitializer; impl FormatRule for FormatJsAnyForInOrOfInitializer { type Context = JsFormatContext; - fn format(node: &JsAnyForInOrOfInitializer, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &JsAnyForInOrOfInitializer, f: &mut JsFormatter) -> FormatResult<()> { match node { - JsAnyForInOrOfInitializer::JsAnyAssignmentPattern(node) => node.format().format(f), - JsAnyForInOrOfInitializer::JsForVariableDeclaration(node) => node.format().format(f), + JsAnyForInOrOfInitializer::JsAnyAssignmentPattern(node) => node.format().fmt(f), + JsAnyForInOrOfInitializer::JsForVariableDeclaration(node) => node.format().fmt(f), } } } diff --git a/crates/rome_js_formatter/src/js/any/for_initializer.rs b/crates/rome_js_formatter/src/js/any/for_initializer.rs index 60f2a54c0ad..0414467a8b1 100644 --- a/crates/rome_js_formatter/src/js/any/for_initializer.rs +++ b/crates/rome_js_formatter/src/js/any/for_initializer.rs @@ -5,10 +5,10 @@ use crate::prelude::*; use rome_js_syntax::JsAnyForInitializer; impl FormatRule for FormatJsAnyForInitializer { type Context = JsFormatContext; - fn format(node: &JsAnyForInitializer, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &JsAnyForInitializer, f: &mut JsFormatter) -> FormatResult<()> { match node { - JsAnyForInitializer::JsVariableDeclaration(node) => node.format().format(f), - JsAnyForInitializer::JsAnyExpression(node) => node.format().format(f), + JsAnyForInitializer::JsVariableDeclaration(node) => node.format().fmt(f), + JsAnyForInitializer::JsAnyExpression(node) => node.format().fmt(f), } } } diff --git a/crates/rome_js_formatter/src/js/any/formal_parameter.rs b/crates/rome_js_formatter/src/js/any/formal_parameter.rs index 2a5da1a527e..241ce4426d7 100644 --- a/crates/rome_js_formatter/src/js/any/formal_parameter.rs +++ b/crates/rome_js_formatter/src/js/any/formal_parameter.rs @@ -5,10 +5,10 @@ use crate::prelude::*; use rome_js_syntax::JsAnyFormalParameter; impl FormatRule for FormatJsAnyFormalParameter { type Context = JsFormatContext; - fn format(node: &JsAnyFormalParameter, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &JsAnyFormalParameter, f: &mut JsFormatter) -> FormatResult<()> { match node { - JsAnyFormalParameter::JsFormalParameter(node) => node.format().format(f), - JsAnyFormalParameter::JsUnknownParameter(node) => node.format().format(f), + JsAnyFormalParameter::JsFormalParameter(node) => node.format().fmt(f), + JsAnyFormalParameter::JsUnknownParameter(node) => node.format().fmt(f), } } } diff --git a/crates/rome_js_formatter/src/js/any/function.rs b/crates/rome_js_formatter/src/js/any/function.rs index b139a7c9a79..3b670c61808 100644 --- a/crates/rome_js_formatter/src/js/any/function.rs +++ b/crates/rome_js_formatter/src/js/any/function.rs @@ -9,7 +9,7 @@ use rome_js_syntax::{ impl FormatRule for FormatJsAnyFunction { type Context = JsFormatContext; - fn format(node: &JsAnyFunction, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &JsAnyFunction, f: &mut JsFormatter) -> FormatResult<()> { if let Some(async_token) = node.async_token() { write!(f, [async_token.format(), space_token()])?; } @@ -35,9 +35,12 @@ impl FormatRule for FormatJsAnyFunction { match node.parameters()? { JsAnyArrowFunctionParameters::JsAnyBinding(binding) => write!( f, - [group_elements(format_args![ + [group_elements(&format_args![ token("("), - soft_block_indent(format_args![binding.format(), if_group_breaks(token(",")),]), + soft_block_indent(&format_args![ + binding.format(), + if_group_breaks(&token(",")), + ]), token(")"), ])] )?, @@ -97,7 +100,7 @@ impl FormatRule for FormatJsAnyFunction { } else { write!( f, - [group_elements(soft_line_indent_or_space( + [group_elements(&soft_line_indent_or_space( &node.body().format() ))] )?; diff --git a/crates/rome_js_formatter/src/js/any/function_body.rs b/crates/rome_js_formatter/src/js/any/function_body.rs index 05c38962c7e..a7e3cb408cd 100644 --- a/crates/rome_js_formatter/src/js/any/function_body.rs +++ b/crates/rome_js_formatter/src/js/any/function_body.rs @@ -5,10 +5,10 @@ use crate::prelude::*; use rome_js_syntax::JsAnyFunctionBody; impl FormatRule for FormatJsAnyFunctionBody { type Context = JsFormatContext; - fn format(node: &JsAnyFunctionBody, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &JsAnyFunctionBody, f: &mut JsFormatter) -> FormatResult<()> { match node { - JsAnyFunctionBody::JsAnyExpression(node) => node.format().format(f), - JsAnyFunctionBody::JsFunctionBody(node) => node.format().format(f), + JsAnyFunctionBody::JsAnyExpression(node) => node.format().fmt(f), + JsAnyFunctionBody::JsFunctionBody(node) => node.format().fmt(f), } } } diff --git a/crates/rome_js_formatter/src/js/any/import_assertion_entry.rs b/crates/rome_js_formatter/src/js/any/import_assertion_entry.rs index 5868fbab651..d3e9ba7219e 100644 --- a/crates/rome_js_formatter/src/js/any/import_assertion_entry.rs +++ b/crates/rome_js_formatter/src/js/any/import_assertion_entry.rs @@ -5,12 +5,10 @@ use crate::prelude::*; use rome_js_syntax::JsAnyImportAssertionEntry; impl FormatRule for FormatJsAnyImportAssertionEntry { type Context = JsFormatContext; - fn format(node: &JsAnyImportAssertionEntry, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &JsAnyImportAssertionEntry, f: &mut JsFormatter) -> FormatResult<()> { match node { - JsAnyImportAssertionEntry::JsImportAssertionEntry(node) => node.format().format(f), - JsAnyImportAssertionEntry::JsUnknownImportAssertionEntry(node) => { - node.format().format(f) - } + JsAnyImportAssertionEntry::JsImportAssertionEntry(node) => node.format().fmt(f), + JsAnyImportAssertionEntry::JsUnknownImportAssertionEntry(node) => node.format().fmt(f), } } } diff --git a/crates/rome_js_formatter/src/js/any/import_clause.rs b/crates/rome_js_formatter/src/js/any/import_clause.rs index 6ed2fa9bbc8..489b5ccded8 100644 --- a/crates/rome_js_formatter/src/js/any/import_clause.rs +++ b/crates/rome_js_formatter/src/js/any/import_clause.rs @@ -5,12 +5,12 @@ use crate::prelude::*; use rome_js_syntax::JsAnyImportClause; impl FormatRule for FormatJsAnyImportClause { type Context = JsFormatContext; - fn format(node: &JsAnyImportClause, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &JsAnyImportClause, f: &mut JsFormatter) -> FormatResult<()> { match node { - JsAnyImportClause::JsImportBareClause(node) => node.format().format(f), - JsAnyImportClause::JsImportNamedClause(node) => node.format().format(f), - JsAnyImportClause::JsImportDefaultClause(node) => node.format().format(f), - JsAnyImportClause::JsImportNamespaceClause(node) => node.format().format(f), + JsAnyImportClause::JsImportBareClause(node) => node.format().fmt(f), + JsAnyImportClause::JsImportNamedClause(node) => node.format().fmt(f), + JsAnyImportClause::JsImportDefaultClause(node) => node.format().fmt(f), + JsAnyImportClause::JsImportNamespaceClause(node) => node.format().fmt(f), } } } diff --git a/crates/rome_js_formatter/src/js/any/in_property.rs b/crates/rome_js_formatter/src/js/any/in_property.rs index 373bede6482..254407cd1f3 100644 --- a/crates/rome_js_formatter/src/js/any/in_property.rs +++ b/crates/rome_js_formatter/src/js/any/in_property.rs @@ -5,10 +5,10 @@ use crate::prelude::*; use rome_js_syntax::JsAnyInProperty; impl FormatRule for FormatJsAnyInProperty { type Context = JsFormatContext; - fn format(node: &JsAnyInProperty, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &JsAnyInProperty, f: &mut JsFormatter) -> FormatResult<()> { match node { - JsAnyInProperty::JsPrivateName(node) => node.format().format(f), - JsAnyInProperty::JsAnyExpression(node) => node.format().format(f), + JsAnyInProperty::JsPrivateName(node) => node.format().fmt(f), + JsAnyInProperty::JsAnyExpression(node) => node.format().fmt(f), } } } diff --git a/crates/rome_js_formatter/src/js/any/literal_expression.rs b/crates/rome_js_formatter/src/js/any/literal_expression.rs index f9c2bfeef4b..698ff637fd1 100644 --- a/crates/rome_js_formatter/src/js/any/literal_expression.rs +++ b/crates/rome_js_formatter/src/js/any/literal_expression.rs @@ -5,14 +5,14 @@ use crate::prelude::*; use rome_js_syntax::JsAnyLiteralExpression; impl FormatRule for FormatJsAnyLiteralExpression { type Context = JsFormatContext; - fn format(node: &JsAnyLiteralExpression, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &JsAnyLiteralExpression, f: &mut JsFormatter) -> FormatResult<()> { match node { - JsAnyLiteralExpression::JsStringLiteralExpression(node) => node.format().format(f), - JsAnyLiteralExpression::JsNumberLiteralExpression(node) => node.format().format(f), - JsAnyLiteralExpression::JsBigIntLiteralExpression(node) => node.format().format(f), - JsAnyLiteralExpression::JsBooleanLiteralExpression(node) => node.format().format(f), - JsAnyLiteralExpression::JsNullLiteralExpression(node) => node.format().format(f), - JsAnyLiteralExpression::JsRegexLiteralExpression(node) => node.format().format(f), + JsAnyLiteralExpression::JsStringLiteralExpression(node) => node.format().fmt(f), + JsAnyLiteralExpression::JsNumberLiteralExpression(node) => node.format().fmt(f), + JsAnyLiteralExpression::JsBigIntLiteralExpression(node) => node.format().fmt(f), + JsAnyLiteralExpression::JsBooleanLiteralExpression(node) => node.format().fmt(f), + JsAnyLiteralExpression::JsNullLiteralExpression(node) => node.format().fmt(f), + JsAnyLiteralExpression::JsRegexLiteralExpression(node) => node.format().fmt(f), } } } diff --git a/crates/rome_js_formatter/src/js/any/method_modifier.rs b/crates/rome_js_formatter/src/js/any/method_modifier.rs index f4ffd437ab7..05d97e4eac2 100644 --- a/crates/rome_js_formatter/src/js/any/method_modifier.rs +++ b/crates/rome_js_formatter/src/js/any/method_modifier.rs @@ -5,11 +5,11 @@ use crate::prelude::*; use rome_js_syntax::JsAnyMethodModifier; impl FormatRule for FormatJsAnyMethodModifier { type Context = JsFormatContext; - fn format(node: &JsAnyMethodModifier, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &JsAnyMethodModifier, f: &mut JsFormatter) -> FormatResult<()> { match node { - JsAnyMethodModifier::TsAccessibilityModifier(node) => node.format().format(f), - JsAnyMethodModifier::JsStaticModifier(node) => node.format().format(f), - JsAnyMethodModifier::TsOverrideModifier(node) => node.format().format(f), + JsAnyMethodModifier::TsAccessibilityModifier(node) => node.format().fmt(f), + JsAnyMethodModifier::JsStaticModifier(node) => node.format().fmt(f), + JsAnyMethodModifier::TsOverrideModifier(node) => node.format().fmt(f), } } } diff --git a/crates/rome_js_formatter/src/js/any/module_item.rs b/crates/rome_js_formatter/src/js/any/module_item.rs index db5970caded..e53454ccdf7 100644 --- a/crates/rome_js_formatter/src/js/any/module_item.rs +++ b/crates/rome_js_formatter/src/js/any/module_item.rs @@ -5,11 +5,11 @@ use crate::prelude::*; use rome_js_syntax::JsAnyModuleItem; impl FormatRule for FormatJsAnyModuleItem { type Context = JsFormatContext; - fn format(node: &JsAnyModuleItem, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &JsAnyModuleItem, f: &mut JsFormatter) -> FormatResult<()> { match node { - JsAnyModuleItem::JsAnyStatement(node) => node.format().format(f), - JsAnyModuleItem::JsExport(node) => node.format().format(f), - JsAnyModuleItem::JsImport(node) => node.format().format(f), + JsAnyModuleItem::JsAnyStatement(node) => node.format().fmt(f), + JsAnyModuleItem::JsExport(node) => node.format().fmt(f), + JsAnyModuleItem::JsImport(node) => node.format().fmt(f), } } } diff --git a/crates/rome_js_formatter/src/js/any/name.rs b/crates/rome_js_formatter/src/js/any/name.rs index b4b8f1a2841..2ecdc7d2e07 100644 --- a/crates/rome_js_formatter/src/js/any/name.rs +++ b/crates/rome_js_formatter/src/js/any/name.rs @@ -5,10 +5,10 @@ use crate::prelude::*; use rome_js_syntax::JsAnyName; impl FormatRule for FormatJsAnyName { type Context = JsFormatContext; - fn format(node: &JsAnyName, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &JsAnyName, f: &mut JsFormatter) -> FormatResult<()> { match node { - JsAnyName::JsName(node) => node.format().format(f), - JsAnyName::JsPrivateName(node) => node.format().format(f), + JsAnyName::JsName(node) => node.format().fmt(f), + JsAnyName::JsPrivateName(node) => node.format().fmt(f), } } } diff --git a/crates/rome_js_formatter/src/js/any/named_import.rs b/crates/rome_js_formatter/src/js/any/named_import.rs index e89d154a2a0..c40655ce6e5 100644 --- a/crates/rome_js_formatter/src/js/any/named_import.rs +++ b/crates/rome_js_formatter/src/js/any/named_import.rs @@ -5,10 +5,10 @@ use crate::prelude::*; use rome_js_syntax::JsAnyNamedImport; impl FormatRule for FormatJsAnyNamedImport { type Context = JsFormatContext; - fn format(node: &JsAnyNamedImport, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &JsAnyNamedImport, f: &mut JsFormatter) -> FormatResult<()> { match node { - JsAnyNamedImport::JsNamedImportSpecifiers(node) => node.format().format(f), - JsAnyNamedImport::JsNamespaceImportSpecifier(node) => node.format().format(f), + JsAnyNamedImport::JsNamedImportSpecifiers(node) => node.format().fmt(f), + JsAnyNamedImport::JsNamespaceImportSpecifier(node) => node.format().fmt(f), } } } diff --git a/crates/rome_js_formatter/src/js/any/named_import_specifier.rs b/crates/rome_js_formatter/src/js/any/named_import_specifier.rs index 515575e0da4..e38098ca5ce 100644 --- a/crates/rome_js_formatter/src/js/any/named_import_specifier.rs +++ b/crates/rome_js_formatter/src/js/any/named_import_specifier.rs @@ -5,15 +5,13 @@ use crate::prelude::*; use rome_js_syntax::JsAnyNamedImportSpecifier; impl FormatRule for FormatJsAnyNamedImportSpecifier { type Context = JsFormatContext; - fn format(node: &JsAnyNamedImportSpecifier, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &JsAnyNamedImportSpecifier, f: &mut JsFormatter) -> FormatResult<()> { match node { JsAnyNamedImportSpecifier::JsShorthandNamedImportSpecifier(node) => { - node.format().format(f) - } - JsAnyNamedImportSpecifier::JsNamedImportSpecifier(node) => node.format().format(f), - JsAnyNamedImportSpecifier::JsUnknownNamedImportSpecifier(node) => { - node.format().format(f) + node.format().fmt(f) } + JsAnyNamedImportSpecifier::JsNamedImportSpecifier(node) => node.format().fmt(f), + JsAnyNamedImportSpecifier::JsUnknownNamedImportSpecifier(node) => node.format().fmt(f), } } } diff --git a/crates/rome_js_formatter/src/js/any/object_assignment_pattern_member.rs b/crates/rome_js_formatter/src/js/any/object_assignment_pattern_member.rs index 9eea65b75ec..d9b1ca97dab 100644 --- a/crates/rome_js_formatter/src/js/any/object_assignment_pattern_member.rs +++ b/crates/rome_js_formatter/src/js/any/object_assignment_pattern_member.rs @@ -5,20 +5,18 @@ use crate::prelude::*; use rome_js_syntax::JsAnyObjectAssignmentPatternMember; impl FormatRule for FormatJsAnyObjectAssignmentPatternMember { type Context = JsFormatContext; - fn format(node: &JsAnyObjectAssignmentPatternMember, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &JsAnyObjectAssignmentPatternMember, f: &mut JsFormatter) -> FormatResult<()> { match node { JsAnyObjectAssignmentPatternMember::JsObjectAssignmentPatternShorthandProperty( node, - ) => node.format().format(f), + ) => node.format().fmt(f), JsAnyObjectAssignmentPatternMember::JsObjectAssignmentPatternProperty(node) => { - node.format().format(f) + node.format().fmt(f) } JsAnyObjectAssignmentPatternMember::JsObjectAssignmentPatternRest(node) => { - node.format().format(f) - } - JsAnyObjectAssignmentPatternMember::JsUnknownAssignment(node) => { - node.format().format(f) + node.format().fmt(f) } + JsAnyObjectAssignmentPatternMember::JsUnknownAssignment(node) => node.format().fmt(f), } } } diff --git a/crates/rome_js_formatter/src/js/any/object_binding_pattern_member.rs b/crates/rome_js_formatter/src/js/any/object_binding_pattern_member.rs index fe4dc4dc295..f4c0e142abe 100644 --- a/crates/rome_js_formatter/src/js/any/object_binding_pattern_member.rs +++ b/crates/rome_js_formatter/src/js/any/object_binding_pattern_member.rs @@ -5,19 +5,19 @@ use crate::prelude::*; use rome_js_syntax::JsAnyObjectBindingPatternMember; impl FormatRule for FormatJsAnyObjectBindingPatternMember { type Context = JsFormatContext; - fn format(node: &JsAnyObjectBindingPatternMember, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &JsAnyObjectBindingPatternMember, f: &mut JsFormatter) -> FormatResult<()> { match node { JsAnyObjectBindingPatternMember::JsObjectBindingPatternProperty(node) => { - node.format().format(f) + node.format().fmt(f) } JsAnyObjectBindingPatternMember::JsObjectBindingPatternRest(node) => { - node.format().format(f) + node.format().fmt(f) } JsAnyObjectBindingPatternMember::JsObjectBindingPatternShorthandProperty(node) => { - node.format().format(f) + node.format().fmt(f) } - JsAnyObjectBindingPatternMember::JsIdentifierBinding(node) => node.format().format(f), - JsAnyObjectBindingPatternMember::JsUnknownBinding(node) => node.format().format(f), + JsAnyObjectBindingPatternMember::JsIdentifierBinding(node) => node.format().fmt(f), + JsAnyObjectBindingPatternMember::JsUnknownBinding(node) => node.format().fmt(f), } } } diff --git a/crates/rome_js_formatter/src/js/any/object_member.rs b/crates/rome_js_formatter/src/js/any/object_member.rs index f2ef11afdab..678b2882240 100644 --- a/crates/rome_js_formatter/src/js/any/object_member.rs +++ b/crates/rome_js_formatter/src/js/any/object_member.rs @@ -5,15 +5,15 @@ use crate::prelude::*; use rome_js_syntax::JsAnyObjectMember; impl FormatRule for FormatJsAnyObjectMember { type Context = JsFormatContext; - fn format(node: &JsAnyObjectMember, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &JsAnyObjectMember, f: &mut JsFormatter) -> FormatResult<()> { match node { - JsAnyObjectMember::JsPropertyObjectMember(node) => node.format().format(f), - JsAnyObjectMember::JsMethodObjectMember(node) => node.format().format(f), - JsAnyObjectMember::JsGetterObjectMember(node) => node.format().format(f), - JsAnyObjectMember::JsSetterObjectMember(node) => node.format().format(f), - JsAnyObjectMember::JsShorthandPropertyObjectMember(node) => node.format().format(f), - JsAnyObjectMember::JsSpread(node) => node.format().format(f), - JsAnyObjectMember::JsUnknownMember(node) => node.format().format(f), + JsAnyObjectMember::JsPropertyObjectMember(node) => node.format().fmt(f), + JsAnyObjectMember::JsMethodObjectMember(node) => node.format().fmt(f), + JsAnyObjectMember::JsGetterObjectMember(node) => node.format().fmt(f), + JsAnyObjectMember::JsSetterObjectMember(node) => node.format().fmt(f), + JsAnyObjectMember::JsShorthandPropertyObjectMember(node) => node.format().fmt(f), + JsAnyObjectMember::JsSpread(node) => node.format().fmt(f), + JsAnyObjectMember::JsUnknownMember(node) => node.format().fmt(f), } } } diff --git a/crates/rome_js_formatter/src/js/any/object_member_name.rs b/crates/rome_js_formatter/src/js/any/object_member_name.rs index c0764d6f624..53bedbf2238 100644 --- a/crates/rome_js_formatter/src/js/any/object_member_name.rs +++ b/crates/rome_js_formatter/src/js/any/object_member_name.rs @@ -5,10 +5,10 @@ use crate::prelude::*; use rome_js_syntax::JsAnyObjectMemberName; impl FormatRule for FormatJsAnyObjectMemberName { type Context = JsFormatContext; - fn format(node: &JsAnyObjectMemberName, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &JsAnyObjectMemberName, f: &mut JsFormatter) -> FormatResult<()> { match node { - JsAnyObjectMemberName::JsLiteralMemberName(node) => node.format().format(f), - JsAnyObjectMemberName::JsComputedMemberName(node) => node.format().format(f), + JsAnyObjectMemberName::JsLiteralMemberName(node) => node.format().fmt(f), + JsAnyObjectMemberName::JsComputedMemberName(node) => node.format().fmt(f), } } } diff --git a/crates/rome_js_formatter/src/js/any/parameter.rs b/crates/rome_js_formatter/src/js/any/parameter.rs index c33c46d3103..09ebb06ea34 100644 --- a/crates/rome_js_formatter/src/js/any/parameter.rs +++ b/crates/rome_js_formatter/src/js/any/parameter.rs @@ -5,11 +5,11 @@ use crate::prelude::*; use rome_js_syntax::JsAnyParameter; impl FormatRule for FormatJsAnyParameter { type Context = JsFormatContext; - fn format(node: &JsAnyParameter, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &JsAnyParameter, f: &mut JsFormatter) -> FormatResult<()> { match node { - JsAnyParameter::JsAnyFormalParameter(node) => node.format().format(f), - JsAnyParameter::JsRestParameter(node) => node.format().format(f), - JsAnyParameter::TsThisParameter(node) => node.format().format(f), + JsAnyParameter::JsAnyFormalParameter(node) => node.format().fmt(f), + JsAnyParameter::JsRestParameter(node) => node.format().fmt(f), + JsAnyParameter::TsThisParameter(node) => node.format().fmt(f), } } } diff --git a/crates/rome_js_formatter/src/js/any/property_modifier.rs b/crates/rome_js_formatter/src/js/any/property_modifier.rs index 8d216aa8533..2e6b32ab886 100644 --- a/crates/rome_js_formatter/src/js/any/property_modifier.rs +++ b/crates/rome_js_formatter/src/js/any/property_modifier.rs @@ -5,12 +5,12 @@ use crate::prelude::*; use rome_js_syntax::JsAnyPropertyModifier; impl FormatRule for FormatJsAnyPropertyModifier { type Context = JsFormatContext; - fn format(node: &JsAnyPropertyModifier, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &JsAnyPropertyModifier, f: &mut JsFormatter) -> FormatResult<()> { match node { - JsAnyPropertyModifier::TsAccessibilityModifier(node) => node.format().format(f), - JsAnyPropertyModifier::JsStaticModifier(node) => node.format().format(f), - JsAnyPropertyModifier::TsReadonlyModifier(node) => node.format().format(f), - JsAnyPropertyModifier::TsOverrideModifier(node) => node.format().format(f), + JsAnyPropertyModifier::TsAccessibilityModifier(node) => node.format().fmt(f), + JsAnyPropertyModifier::JsStaticModifier(node) => node.format().fmt(f), + JsAnyPropertyModifier::TsReadonlyModifier(node) => node.format().fmt(f), + JsAnyPropertyModifier::TsOverrideModifier(node) => node.format().fmt(f), } } } diff --git a/crates/rome_js_formatter/src/js/any/root.rs b/crates/rome_js_formatter/src/js/any/root.rs index 183cb1722ce..a6179bbb614 100644 --- a/crates/rome_js_formatter/src/js/any/root.rs +++ b/crates/rome_js_formatter/src/js/any/root.rs @@ -5,11 +5,11 @@ use crate::prelude::*; use rome_js_syntax::JsAnyRoot; impl FormatRule for FormatJsAnyRoot { type Context = JsFormatContext; - fn format(node: &JsAnyRoot, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &JsAnyRoot, f: &mut JsFormatter) -> FormatResult<()> { match node { - JsAnyRoot::JsScript(node) => node.format().format(f), - JsAnyRoot::JsModule(node) => node.format().format(f), - JsAnyRoot::JsExpressionSnipped(node) => node.format().format(f), + JsAnyRoot::JsScript(node) => node.format().fmt(f), + JsAnyRoot::JsModule(node) => node.format().fmt(f), + JsAnyRoot::JsExpressionSnipped(node) => node.format().fmt(f), } } } diff --git a/crates/rome_js_formatter/src/js/any/statement.rs b/crates/rome_js_formatter/src/js/any/statement.rs index 6856cdab79b..b788fc30bbf 100644 --- a/crates/rome_js_formatter/src/js/any/statement.rs +++ b/crates/rome_js_formatter/src/js/any/statement.rs @@ -5,40 +5,40 @@ use crate::prelude::*; use rome_js_syntax::JsAnyStatement; impl FormatRule for FormatJsAnyStatement { type Context = JsFormatContext; - fn format(node: &JsAnyStatement, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &JsAnyStatement, f: &mut JsFormatter) -> FormatResult<()> { match node { - JsAnyStatement::JsBlockStatement(node) => node.format().format(f), - JsAnyStatement::JsBreakStatement(node) => node.format().format(f), - JsAnyStatement::JsClassDeclaration(node) => node.format().format(f), - JsAnyStatement::JsContinueStatement(node) => node.format().format(f), - JsAnyStatement::JsDebuggerStatement(node) => node.format().format(f), - JsAnyStatement::JsDoWhileStatement(node) => node.format().format(f), - JsAnyStatement::JsEmptyStatement(node) => node.format().format(f), - JsAnyStatement::JsExpressionStatement(node) => node.format().format(f), - JsAnyStatement::JsForInStatement(node) => node.format().format(f), - JsAnyStatement::JsForOfStatement(node) => node.format().format(f), - JsAnyStatement::JsForStatement(node) => node.format().format(f), - JsAnyStatement::JsIfStatement(node) => node.format().format(f), - JsAnyStatement::JsLabeledStatement(node) => node.format().format(f), - JsAnyStatement::JsReturnStatement(node) => node.format().format(f), - JsAnyStatement::JsSwitchStatement(node) => node.format().format(f), - JsAnyStatement::JsThrowStatement(node) => node.format().format(f), - JsAnyStatement::JsTryFinallyStatement(node) => node.format().format(f), - JsAnyStatement::JsTryStatement(node) => node.format().format(f), - JsAnyStatement::JsUnknownStatement(node) => node.format().format(f), - JsAnyStatement::JsVariableStatement(node) => node.format().format(f), - JsAnyStatement::JsWhileStatement(node) => node.format().format(f), - JsAnyStatement::JsWithStatement(node) => node.format().format(f), - JsAnyStatement::JsFunctionDeclaration(node) => node.format().format(f), - JsAnyStatement::TsEnumDeclaration(node) => node.format().format(f), - JsAnyStatement::TsTypeAliasDeclaration(node) => node.format().format(f), - JsAnyStatement::TsInterfaceDeclaration(node) => node.format().format(f), - JsAnyStatement::TsDeclareFunctionDeclaration(node) => node.format().format(f), - JsAnyStatement::TsDeclareStatement(node) => node.format().format(f), - JsAnyStatement::TsModuleDeclaration(node) => node.format().format(f), - JsAnyStatement::TsExternalModuleDeclaration(node) => node.format().format(f), - JsAnyStatement::TsGlobalDeclaration(node) => node.format().format(f), - JsAnyStatement::TsImportEqualsDeclaration(node) => node.format().format(f), + JsAnyStatement::JsBlockStatement(node) => node.format().fmt(f), + JsAnyStatement::JsBreakStatement(node) => node.format().fmt(f), + JsAnyStatement::JsClassDeclaration(node) => node.format().fmt(f), + JsAnyStatement::JsContinueStatement(node) => node.format().fmt(f), + JsAnyStatement::JsDebuggerStatement(node) => node.format().fmt(f), + JsAnyStatement::JsDoWhileStatement(node) => node.format().fmt(f), + JsAnyStatement::JsEmptyStatement(node) => node.format().fmt(f), + JsAnyStatement::JsExpressionStatement(node) => node.format().fmt(f), + JsAnyStatement::JsForInStatement(node) => node.format().fmt(f), + JsAnyStatement::JsForOfStatement(node) => node.format().fmt(f), + JsAnyStatement::JsForStatement(node) => node.format().fmt(f), + JsAnyStatement::JsIfStatement(node) => node.format().fmt(f), + JsAnyStatement::JsLabeledStatement(node) => node.format().fmt(f), + JsAnyStatement::JsReturnStatement(node) => node.format().fmt(f), + JsAnyStatement::JsSwitchStatement(node) => node.format().fmt(f), + JsAnyStatement::JsThrowStatement(node) => node.format().fmt(f), + JsAnyStatement::JsTryFinallyStatement(node) => node.format().fmt(f), + JsAnyStatement::JsTryStatement(node) => node.format().fmt(f), + JsAnyStatement::JsUnknownStatement(node) => node.format().fmt(f), + JsAnyStatement::JsVariableStatement(node) => node.format().fmt(f), + JsAnyStatement::JsWhileStatement(node) => node.format().fmt(f), + JsAnyStatement::JsWithStatement(node) => node.format().fmt(f), + JsAnyStatement::JsFunctionDeclaration(node) => node.format().fmt(f), + JsAnyStatement::TsEnumDeclaration(node) => node.format().fmt(f), + JsAnyStatement::TsTypeAliasDeclaration(node) => node.format().fmt(f), + JsAnyStatement::TsInterfaceDeclaration(node) => node.format().fmt(f), + JsAnyStatement::TsDeclareFunctionDeclaration(node) => node.format().fmt(f), + JsAnyStatement::TsDeclareStatement(node) => node.format().fmt(f), + JsAnyStatement::TsModuleDeclaration(node) => node.format().fmt(f), + JsAnyStatement::TsExternalModuleDeclaration(node) => node.format().fmt(f), + JsAnyStatement::TsGlobalDeclaration(node) => node.format().fmt(f), + JsAnyStatement::TsImportEqualsDeclaration(node) => node.format().fmt(f), } } } diff --git a/crates/rome_js_formatter/src/js/any/switch_clause.rs b/crates/rome_js_formatter/src/js/any/switch_clause.rs index db3f88ed31b..7f69fb84f0c 100644 --- a/crates/rome_js_formatter/src/js/any/switch_clause.rs +++ b/crates/rome_js_formatter/src/js/any/switch_clause.rs @@ -5,10 +5,10 @@ use crate::prelude::*; use rome_js_syntax::JsAnySwitchClause; impl FormatRule for FormatJsAnySwitchClause { type Context = JsFormatContext; - fn format(node: &JsAnySwitchClause, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &JsAnySwitchClause, f: &mut JsFormatter) -> FormatResult<()> { match node { - JsAnySwitchClause::JsCaseClause(node) => node.format().format(f), - JsAnySwitchClause::JsDefaultClause(node) => node.format().format(f), + JsAnySwitchClause::JsCaseClause(node) => node.format().fmt(f), + JsAnySwitchClause::JsDefaultClause(node) => node.format().fmt(f), } } } diff --git a/crates/rome_js_formatter/src/js/any/template_element.rs b/crates/rome_js_formatter/src/js/any/template_element.rs index cdb12cfd4fc..3ff11357974 100644 --- a/crates/rome_js_formatter/src/js/any/template_element.rs +++ b/crates/rome_js_formatter/src/js/any/template_element.rs @@ -5,10 +5,10 @@ use crate::prelude::*; use rome_js_syntax::JsAnyTemplateElement; impl FormatRule for FormatJsAnyTemplateElement { type Context = JsFormatContext; - fn format(node: &JsAnyTemplateElement, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &JsAnyTemplateElement, f: &mut JsFormatter) -> FormatResult<()> { match node { - JsAnyTemplateElement::JsTemplateChunkElement(node) => node.format().format(f), - JsAnyTemplateElement::JsTemplateElement(node) => node.format().format(f), + JsAnyTemplateElement::JsTemplateChunkElement(node) => node.format().fmt(f), + JsAnyTemplateElement::JsTemplateElement(node) => node.format().fmt(f), } } } diff --git a/crates/rome_js_formatter/src/js/assignments/array_assignment_pattern.rs b/crates/rome_js_formatter/src/js/assignments/array_assignment_pattern.rs index a2bb647e1ae..fbc28169dc1 100644 --- a/crates/rome_js_formatter/src/js/assignments/array_assignment_pattern.rs +++ b/crates/rome_js_formatter/src/js/assignments/array_assignment_pattern.rs @@ -5,7 +5,7 @@ use rome_js_syntax::JsArrayAssignmentPattern; use rome_js_syntax::JsArrayAssignmentPatternFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsArrayAssignmentPattern, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsArrayAssignmentPattern, f: &mut JsFormatter) -> FormatResult<()> { let JsArrayAssignmentPatternFields { l_brack_token, elements, diff --git a/crates/rome_js_formatter/src/js/assignments/array_assignment_pattern_rest_element.rs b/crates/rome_js_formatter/src/js/assignments/array_assignment_pattern_rest_element.rs index b804dc592e2..558ea6bdef2 100644 --- a/crates/rome_js_formatter/src/js/assignments/array_assignment_pattern_rest_element.rs +++ b/crates/rome_js_formatter/src/js/assignments/array_assignment_pattern_rest_element.rs @@ -8,7 +8,7 @@ use rome_js_syntax::JsArrayAssignmentPatternRestElementFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields( + fn fmt_fields( node: &JsArrayAssignmentPatternRestElement, f: &mut JsFormatter, ) -> FormatResult<()> { diff --git a/crates/rome_js_formatter/src/js/assignments/assignment_with_default.rs b/crates/rome_js_formatter/src/js/assignments/assignment_with_default.rs index 4b7d49b2730..01bfaa115fc 100644 --- a/crates/rome_js_formatter/src/js/assignments/assignment_with_default.rs +++ b/crates/rome_js_formatter/src/js/assignments/assignment_with_default.rs @@ -6,7 +6,7 @@ use rome_js_syntax::JsAssignmentWithDefault; use rome_js_syntax::JsAssignmentWithDefaultFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsAssignmentWithDefault, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsAssignmentWithDefault, f: &mut JsFormatter) -> FormatResult<()> { let JsAssignmentWithDefaultFields { pattern, eq_token, diff --git a/crates/rome_js_formatter/src/js/assignments/computed_member_assignment.rs b/crates/rome_js_formatter/src/js/assignments/computed_member_assignment.rs index 3efb83b1f99..9c5debbc27a 100644 --- a/crates/rome_js_formatter/src/js/assignments/computed_member_assignment.rs +++ b/crates/rome_js_formatter/src/js/assignments/computed_member_assignment.rs @@ -6,7 +6,7 @@ use rome_js_syntax::JsComputedMemberAssignment; use rome_js_syntax::JsComputedMemberAssignmentFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsComputedMemberAssignment, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsComputedMemberAssignment, f: &mut JsFormatter) -> FormatResult<()> { let JsComputedMemberAssignmentFields { object, l_brack_token, diff --git a/crates/rome_js_formatter/src/js/assignments/identifier_assignment.rs b/crates/rome_js_formatter/src/js/assignments/identifier_assignment.rs index f14180831d9..7e6e72f0fcd 100644 --- a/crates/rome_js_formatter/src/js/assignments/identifier_assignment.rs +++ b/crates/rome_js_formatter/src/js/assignments/identifier_assignment.rs @@ -6,7 +6,7 @@ use rome_js_syntax::JsIdentifierAssignment; use rome_js_syntax::JsIdentifierAssignmentFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsIdentifierAssignment, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsIdentifierAssignment, f: &mut JsFormatter) -> FormatResult<()> { let JsIdentifierAssignmentFields { name_token } = node.as_fields(); write![f, [name_token.format()]] diff --git a/crates/rome_js_formatter/src/js/assignments/object_assignment_pattern.rs b/crates/rome_js_formatter/src/js/assignments/object_assignment_pattern.rs index 1f2f733818e..2e28e5a2926 100644 --- a/crates/rome_js_formatter/src/js/assignments/object_assignment_pattern.rs +++ b/crates/rome_js_formatter/src/js/assignments/object_assignment_pattern.rs @@ -5,7 +5,7 @@ use rome_js_syntax::JsObjectAssignmentPattern; use rome_js_syntax::JsObjectAssignmentPatternFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsObjectAssignmentPattern, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsObjectAssignmentPattern, f: &mut JsFormatter) -> FormatResult<()> { let JsObjectAssignmentPatternFields { l_curly_token, properties, diff --git a/crates/rome_js_formatter/src/js/assignments/object_assignment_pattern_property.rs b/crates/rome_js_formatter/src/js/assignments/object_assignment_pattern_property.rs index 69a18ef4f19..3823895d8ad 100644 --- a/crates/rome_js_formatter/src/js/assignments/object_assignment_pattern_property.rs +++ b/crates/rome_js_formatter/src/js/assignments/object_assignment_pattern_property.rs @@ -1,6 +1,7 @@ use crate::prelude::*; use rome_formatter::write; +use crate::utils::FormatMemberName; use crate::FormatNodeFields; use rome_js_syntax::JsObjectAssignmentPatternProperty; use rome_js_syntax::JsObjectAssignmentPatternPropertyFields; @@ -8,7 +9,7 @@ use rome_js_syntax::JsObjectAssignmentPatternPropertyFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields( + fn fmt_fields( node: &JsObjectAssignmentPatternProperty, f: &mut JsFormatter, ) -> FormatResult<()> { @@ -22,7 +23,7 @@ impl FormatNodeFields write!( f, [ - member.format(), + FormatMemberName::from(member?), colon_token.format(), space_token(), pattern.format(), diff --git a/crates/rome_js_formatter/src/js/assignments/object_assignment_pattern_rest.rs b/crates/rome_js_formatter/src/js/assignments/object_assignment_pattern_rest.rs index 6835604b8c4..d8482c6f38e 100644 --- a/crates/rome_js_formatter/src/js/assignments/object_assignment_pattern_rest.rs +++ b/crates/rome_js_formatter/src/js/assignments/object_assignment_pattern_rest.rs @@ -8,10 +8,7 @@ use rome_js_syntax::JsObjectAssignmentPatternRestFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields( - node: &JsObjectAssignmentPatternRest, - f: &mut JsFormatter, - ) -> FormatResult<()> { + fn fmt_fields(node: &JsObjectAssignmentPatternRest, f: &mut JsFormatter) -> FormatResult<()> { let JsObjectAssignmentPatternRestFields { dotdotdot_token, target, diff --git a/crates/rome_js_formatter/src/js/assignments/object_assignment_pattern_shorthand_property.rs b/crates/rome_js_formatter/src/js/assignments/object_assignment_pattern_shorthand_property.rs index b92429f496a..21ac8f4115c 100644 --- a/crates/rome_js_formatter/src/js/assignments/object_assignment_pattern_shorthand_property.rs +++ b/crates/rome_js_formatter/src/js/assignments/object_assignment_pattern_shorthand_property.rs @@ -8,7 +8,7 @@ use rome_js_syntax::JsObjectAssignmentPatternShorthandPropertyFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields( + fn fmt_fields( node: &JsObjectAssignmentPatternShorthandProperty, f: &mut JsFormatter, ) -> FormatResult<()> { diff --git a/crates/rome_js_formatter/src/js/assignments/parenthesized_assignment.rs b/crates/rome_js_formatter/src/js/assignments/parenthesized_assignment.rs index ff57e5a45ed..108089989b0 100644 --- a/crates/rome_js_formatter/src/js/assignments/parenthesized_assignment.rs +++ b/crates/rome_js_formatter/src/js/assignments/parenthesized_assignment.rs @@ -5,7 +5,7 @@ use rome_js_syntax::JsParenthesizedAssignment; use rome_js_syntax::JsParenthesizedAssignmentFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsParenthesizedAssignment, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsParenthesizedAssignment, f: &mut JsFormatter) -> FormatResult<()> { let JsParenthesizedAssignmentFields { l_paren_token, assignment, diff --git a/crates/rome_js_formatter/src/js/assignments/static_member_assignment.rs b/crates/rome_js_formatter/src/js/assignments/static_member_assignment.rs index 9d8b6be0d0a..3114e7882f1 100644 --- a/crates/rome_js_formatter/src/js/assignments/static_member_assignment.rs +++ b/crates/rome_js_formatter/src/js/assignments/static_member_assignment.rs @@ -5,7 +5,7 @@ use rome_js_syntax::JsStaticMemberAssignment; use rome_js_syntax::JsStaticMemberAssignmentFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsStaticMemberAssignment, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsStaticMemberAssignment, f: &mut JsFormatter) -> FormatResult<()> { let JsStaticMemberAssignmentFields { object, dot_token, diff --git a/crates/rome_js_formatter/src/js/auxiliary/array_hole.rs b/crates/rome_js_formatter/src/js/auxiliary/array_hole.rs index 4dc7f0f5e63..63102880a14 100644 --- a/crates/rome_js_formatter/src/js/auxiliary/array_hole.rs +++ b/crates/rome_js_formatter/src/js/auxiliary/array_hole.rs @@ -4,7 +4,7 @@ use crate::FormatNodeFields; use rome_js_syntax::JsArrayHole; impl FormatNodeFields for FormatNodeRule { - fn format_fields(_: &JsArrayHole, _: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(_: &JsArrayHole, _: &mut JsFormatter) -> FormatResult<()> { Ok(()) } } diff --git a/crates/rome_js_formatter/src/js/auxiliary/case_clause.rs b/crates/rome_js_formatter/src/js/auxiliary/case_clause.rs index c54a119f9ff..200efbe8736 100644 --- a/crates/rome_js_formatter/src/js/auxiliary/case_clause.rs +++ b/crates/rome_js_formatter/src/js/auxiliary/case_clause.rs @@ -7,7 +7,7 @@ use rome_js_syntax::JsCaseClauseFields; use rome_rowan::AstNodeList; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsCaseClause, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsCaseClause, f: &mut JsFormatter) -> FormatResult<()> { let JsCaseClauseFields { case_token, test, @@ -49,7 +49,7 @@ impl FormatNodeFields for FormatNodeRule { // no line break needed after because it is added by the indent in the switch statement write!( f, - [indent(format_args![hard_line_break(), format_consequent])] + [indent(&format_args![hard_line_break(), format_consequent])] ) } } diff --git a/crates/rome_js_formatter/src/js/auxiliary/catch_clause.rs b/crates/rome_js_formatter/src/js/auxiliary/catch_clause.rs index d461caf60b0..28370f2b5d0 100644 --- a/crates/rome_js_formatter/src/js/auxiliary/catch_clause.rs +++ b/crates/rome_js_formatter/src/js/auxiliary/catch_clause.rs @@ -5,7 +5,7 @@ use rome_js_syntax::JsCatchClause; use rome_js_syntax::JsCatchClauseFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsCatchClause, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsCatchClause, f: &mut JsFormatter) -> FormatResult<()> { let JsCatchClauseFields { catch_token, declaration, diff --git a/crates/rome_js_formatter/src/js/auxiliary/default_clause.rs b/crates/rome_js_formatter/src/js/auxiliary/default_clause.rs index cd39370fd42..2abae4a8fc8 100644 --- a/crates/rome_js_formatter/src/js/auxiliary/default_clause.rs +++ b/crates/rome_js_formatter/src/js/auxiliary/default_clause.rs @@ -6,7 +6,7 @@ use rome_js_syntax::{JsAnyStatement, JsDefaultClauseFields}; use rome_rowan::AstNodeList; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsDefaultClause, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsDefaultClause, f: &mut JsFormatter) -> FormatResult<()> { let JsDefaultClauseFields { default_token, colon_token, @@ -40,7 +40,7 @@ impl FormatNodeFields for FormatNodeRule { // no line break needed after because it is added by the indent in the switch statement write!( f, - [indent(format_args!(hard_line_break(), format_statements))] + [indent(&format_args!(hard_line_break(), format_statements))] ) } } diff --git a/crates/rome_js_formatter/src/js/auxiliary/directive.rs b/crates/rome_js_formatter/src/js/auxiliary/directive.rs index 1c46c65a954..24703b565c2 100644 --- a/crates/rome_js_formatter/src/js/auxiliary/directive.rs +++ b/crates/rome_js_formatter/src/js/auxiliary/directive.rs @@ -1,5 +1,5 @@ use crate::prelude::*; -use crate::utils::{FormatLiteralStringToken, FormatWithSemicolon}; +use crate::utils::{FormatLiteralStringToken, FormatWithSemicolon, StringLiteralParentKind}; use rome_formatter::write; use crate::FormatNodeFields; @@ -7,7 +7,7 @@ use rome_js_syntax::JsDirective; use rome_js_syntax::JsDirectiveFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsDirective, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsDirective, f: &mut JsFormatter) -> FormatResult<()> { let JsDirectiveFields { value_token, semicolon_token, @@ -16,7 +16,7 @@ impl FormatNodeFields for FormatNodeRule { write!( f, [FormatWithSemicolon::new( - &FormatLiteralStringToken::from_directive(&value_token?), + &FormatLiteralStringToken::new(&value_token?, StringLiteralParentKind::Directive), semicolon_token.as_ref() )] ) diff --git a/crates/rome_js_formatter/src/js/auxiliary/else_clause.rs b/crates/rome_js_formatter/src/js/auxiliary/else_clause.rs index 8de891fde7e..7774d27a271 100644 --- a/crates/rome_js_formatter/src/js/auxiliary/else_clause.rs +++ b/crates/rome_js_formatter/src/js/auxiliary/else_clause.rs @@ -5,7 +5,7 @@ use rome_js_syntax::JsElseClause; use rome_js_syntax::JsElseClauseFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsElseClause, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsElseClause, f: &mut JsFormatter) -> FormatResult<()> { let JsElseClauseFields { else_token, alternate, diff --git a/crates/rome_js_formatter/src/js/auxiliary/expression_snipped.rs b/crates/rome_js_formatter/src/js/auxiliary/expression_snipped.rs index 7c82eb0793d..a71615951bc 100644 --- a/crates/rome_js_formatter/src/js/auxiliary/expression_snipped.rs +++ b/crates/rome_js_formatter/src/js/auxiliary/expression_snipped.rs @@ -5,7 +5,7 @@ use rome_js_syntax::JsExpressionSnipped; use rome_js_syntax::JsExpressionSnippedFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsExpressionSnipped, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsExpressionSnipped, f: &mut JsFormatter) -> FormatResult<()> { let JsExpressionSnippedFields { expression, eof_token, diff --git a/crates/rome_js_formatter/src/js/auxiliary/finally_clause.rs b/crates/rome_js_formatter/src/js/auxiliary/finally_clause.rs index 6bc034c9a9e..ecd74e54f6f 100644 --- a/crates/rome_js_formatter/src/js/auxiliary/finally_clause.rs +++ b/crates/rome_js_formatter/src/js/auxiliary/finally_clause.rs @@ -5,7 +5,7 @@ use rome_js_syntax::JsFinallyClause; use rome_js_syntax::JsFinallyClauseFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsFinallyClause, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsFinallyClause, f: &mut JsFormatter) -> FormatResult<()> { let JsFinallyClauseFields { finally_token, body, diff --git a/crates/rome_js_formatter/src/js/auxiliary/function_body.rs b/crates/rome_js_formatter/src/js/auxiliary/function_body.rs index 9b3f7dfcffa..7c2c4bf7471 100644 --- a/crates/rome_js_formatter/src/js/auxiliary/function_body.rs +++ b/crates/rome_js_formatter/src/js/auxiliary/function_body.rs @@ -5,7 +5,7 @@ use rome_js_syntax::JsFunctionBody; use rome_js_syntax::JsFunctionBodyFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsFunctionBody, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsFunctionBody, f: &mut JsFormatter) -> FormatResult<()> { let JsFunctionBodyFields { l_curly_token, directives, @@ -27,7 +27,7 @@ impl FormatNodeFields for FormatNodeRule { f, [format_delimited( &l_curly_token?, - format_args![directives.format(), format_statements], + &format_args![directives.format(), format_statements], &r_curly_token?, ) .block_indent()] diff --git a/crates/rome_js_formatter/src/js/auxiliary/initializer_clause.rs b/crates/rome_js_formatter/src/js/auxiliary/initializer_clause.rs index 9e5790c8499..848bfb59daf 100644 --- a/crates/rome_js_formatter/src/js/auxiliary/initializer_clause.rs +++ b/crates/rome_js_formatter/src/js/auxiliary/initializer_clause.rs @@ -5,7 +5,7 @@ use rome_js_syntax::JsInitializerClause; use rome_js_syntax::JsInitializerClauseFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsInitializerClause, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsInitializerClause, f: &mut JsFormatter) -> FormatResult<()> { let JsInitializerClauseFields { eq_token, expression, diff --git a/crates/rome_js_formatter/src/js/auxiliary/module.rs b/crates/rome_js_formatter/src/js/auxiliary/module.rs index cd3491489c7..38fb5f8ad2b 100644 --- a/crates/rome_js_formatter/src/js/auxiliary/module.rs +++ b/crates/rome_js_formatter/src/js/auxiliary/module.rs @@ -7,7 +7,7 @@ use rome_js_syntax::JsModule; use rome_js_syntax::JsModuleFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsModule, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsModule, f: &mut JsFormatter) -> FormatResult<()> { let JsModuleFields { interpreter_token, directives, diff --git a/crates/rome_js_formatter/src/js/auxiliary/name.rs b/crates/rome_js_formatter/src/js/auxiliary/name.rs index c91ac0890ae..cd21c41e6d2 100644 --- a/crates/rome_js_formatter/src/js/auxiliary/name.rs +++ b/crates/rome_js_formatter/src/js/auxiliary/name.rs @@ -5,7 +5,7 @@ use rome_js_syntax::JsName; use rome_js_syntax::JsNameFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsName, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsName, f: &mut JsFormatter) -> FormatResult<()> { let JsNameFields { value_token } = node.as_fields(); write![f, [value_token.format()]] diff --git a/crates/rome_js_formatter/src/js/auxiliary/new_target.rs b/crates/rome_js_formatter/src/js/auxiliary/new_target.rs index 0979c70dfa1..e74436d39d6 100644 --- a/crates/rome_js_formatter/src/js/auxiliary/new_target.rs +++ b/crates/rome_js_formatter/src/js/auxiliary/new_target.rs @@ -5,7 +5,7 @@ use rome_js_syntax::NewTarget; use rome_js_syntax::NewTargetFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &NewTarget, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &NewTarget, f: &mut JsFormatter) -> FormatResult<()> { let NewTargetFields { new_token, dot_token, diff --git a/crates/rome_js_formatter/src/js/auxiliary/private_name.rs b/crates/rome_js_formatter/src/js/auxiliary/private_name.rs index e21b821f9fd..3aa40d681ba 100644 --- a/crates/rome_js_formatter/src/js/auxiliary/private_name.rs +++ b/crates/rome_js_formatter/src/js/auxiliary/private_name.rs @@ -5,7 +5,7 @@ use rome_js_syntax::JsPrivateName; use rome_js_syntax::JsPrivateNameFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsPrivateName, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsPrivateName, f: &mut JsFormatter) -> FormatResult<()> { let JsPrivateNameFields { hash_token, value_token, diff --git a/crates/rome_js_formatter/src/js/auxiliary/reference_identifier.rs b/crates/rome_js_formatter/src/js/auxiliary/reference_identifier.rs index bc34ef1e51c..47a7270a26a 100644 --- a/crates/rome_js_formatter/src/js/auxiliary/reference_identifier.rs +++ b/crates/rome_js_formatter/src/js/auxiliary/reference_identifier.rs @@ -5,7 +5,7 @@ use rome_js_syntax::JsReferenceIdentifier; use rome_js_syntax::JsReferenceIdentifierFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsReferenceIdentifier, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsReferenceIdentifier, f: &mut JsFormatter) -> FormatResult<()> { let JsReferenceIdentifierFields { value_token } = node.as_fields(); write![f, [value_token.format()]] diff --git a/crates/rome_js_formatter/src/js/auxiliary/script.rs b/crates/rome_js_formatter/src/js/auxiliary/script.rs index e7dd9abfecd..188f1bff343 100644 --- a/crates/rome_js_formatter/src/js/auxiliary/script.rs +++ b/crates/rome_js_formatter/src/js/auxiliary/script.rs @@ -7,7 +7,7 @@ use rome_js_syntax::JsScript; use rome_js_syntax::JsScriptFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsScript, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsScript, f: &mut JsFormatter) -> FormatResult<()> { let JsScriptFields { interpreter_token, directives, diff --git a/crates/rome_js_formatter/src/js/auxiliary/spread.rs b/crates/rome_js_formatter/src/js/auxiliary/spread.rs index 63469e0fcf8..ec07631d2f3 100644 --- a/crates/rome_js_formatter/src/js/auxiliary/spread.rs +++ b/crates/rome_js_formatter/src/js/auxiliary/spread.rs @@ -5,7 +5,7 @@ use rome_js_syntax::JsSpread; use rome_js_syntax::JsSpreadFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsSpread, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsSpread, f: &mut JsFormatter) -> FormatResult<()> { let JsSpreadFields { dotdotdot_token, argument, diff --git a/crates/rome_js_formatter/src/js/auxiliary/static_modifier.rs b/crates/rome_js_formatter/src/js/auxiliary/static_modifier.rs index b96ebb25e7e..af3db1badba 100644 --- a/crates/rome_js_formatter/src/js/auxiliary/static_modifier.rs +++ b/crates/rome_js_formatter/src/js/auxiliary/static_modifier.rs @@ -6,7 +6,7 @@ use rome_js_syntax::JsStaticModifier; use rome_js_syntax::JsStaticModifierFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsStaticModifier, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsStaticModifier, f: &mut JsFormatter) -> FormatResult<()> { let JsStaticModifierFields { modifier_token } = node.as_fields(); write![f, [modifier_token.format()]] diff --git a/crates/rome_js_formatter/src/js/auxiliary/variable_declaration_clause.rs b/crates/rome_js_formatter/src/js/auxiliary/variable_declaration_clause.rs index 9aae17b5128..6784dbf2980 100644 --- a/crates/rome_js_formatter/src/js/auxiliary/variable_declaration_clause.rs +++ b/crates/rome_js_formatter/src/js/auxiliary/variable_declaration_clause.rs @@ -1,23 +1,16 @@ use crate::prelude::*; use crate::utils::FormatWithSemicolon; use crate::FormatNodeFields; -use rome_formatter::write; use rome_js_syntax::JsVariableDeclarationClause; use rome_js_syntax::JsVariableDeclarationClauseFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsVariableDeclarationClause, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsVariableDeclarationClause, f: &mut JsFormatter) -> FormatResult<()> { let JsVariableDeclarationClauseFields { declaration, semicolon_token, } = node.as_fields(); - write!( - f, - [FormatWithSemicolon::new( - &declaration.format(), - semicolon_token.as_ref() - )] - ) + FormatWithSemicolon::new(&declaration.format(), semicolon_token.as_ref()).fmt(f) } } diff --git a/crates/rome_js_formatter/src/js/auxiliary/variable_declarator.rs b/crates/rome_js_formatter/src/js/auxiliary/variable_declarator.rs index 54e585cf574..344e8151464 100644 --- a/crates/rome_js_formatter/src/js/auxiliary/variable_declarator.rs +++ b/crates/rome_js_formatter/src/js/auxiliary/variable_declarator.rs @@ -6,7 +6,7 @@ use rome_js_syntax::JsVariableDeclarator; use rome_js_syntax::JsVariableDeclaratorFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsVariableDeclarator, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsVariableDeclarator, f: &mut JsFormatter) -> FormatResult<()> { let JsVariableDeclaratorFields { id, variable_annotation, diff --git a/crates/rome_js_formatter/src/js/bindings/array_binding_pattern.rs b/crates/rome_js_formatter/src/js/bindings/array_binding_pattern.rs index e93a63423d4..635bf76f45f 100644 --- a/crates/rome_js_formatter/src/js/bindings/array_binding_pattern.rs +++ b/crates/rome_js_formatter/src/js/bindings/array_binding_pattern.rs @@ -5,7 +5,7 @@ use rome_js_syntax::JsArrayBindingPattern; use rome_js_syntax::JsArrayBindingPatternFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsArrayBindingPattern, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsArrayBindingPattern, f: &mut JsFormatter) -> FormatResult<()> { let JsArrayBindingPatternFields { l_brack_token, elements, diff --git a/crates/rome_js_formatter/src/js/bindings/array_binding_pattern_rest_element.rs b/crates/rome_js_formatter/src/js/bindings/array_binding_pattern_rest_element.rs index d7b87fef43f..3cd60bc7e90 100644 --- a/crates/rome_js_formatter/src/js/bindings/array_binding_pattern_rest_element.rs +++ b/crates/rome_js_formatter/src/js/bindings/array_binding_pattern_rest_element.rs @@ -7,7 +7,7 @@ use rome_js_syntax::JsArrayBindingPatternRestElementFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields( + fn fmt_fields( node: &JsArrayBindingPatternRestElement, f: &mut JsFormatter, ) -> FormatResult<()> { diff --git a/crates/rome_js_formatter/src/js/bindings/binding_pattern_with_default.rs b/crates/rome_js_formatter/src/js/bindings/binding_pattern_with_default.rs index ab8c34b4e20..33a47a58609 100644 --- a/crates/rome_js_formatter/src/js/bindings/binding_pattern_with_default.rs +++ b/crates/rome_js_formatter/src/js/bindings/binding_pattern_with_default.rs @@ -5,7 +5,7 @@ use rome_js_syntax::JsBindingPatternWithDefault; use rome_js_syntax::JsBindingPatternWithDefaultFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsBindingPatternWithDefault, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsBindingPatternWithDefault, f: &mut JsFormatter) -> FormatResult<()> { let JsBindingPatternWithDefaultFields { pattern, eq_token, diff --git a/crates/rome_js_formatter/src/js/bindings/constructor_parameters.rs b/crates/rome_js_formatter/src/js/bindings/constructor_parameters.rs index 7890140d8fe..a0698d731d9 100644 --- a/crates/rome_js_formatter/src/js/bindings/constructor_parameters.rs +++ b/crates/rome_js_formatter/src/js/bindings/constructor_parameters.rs @@ -5,7 +5,7 @@ use rome_js_syntax::JsConstructorParameters; use rome_js_syntax::JsConstructorParametersFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsConstructorParameters, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsConstructorParameters, f: &mut JsFormatter) -> FormatResult<()> { let JsConstructorParametersFields { l_paren_token, parameters, diff --git a/crates/rome_js_formatter/src/js/bindings/formal_parameter.rs b/crates/rome_js_formatter/src/js/bindings/formal_parameter.rs index 8f15cbd0fd1..d3035a72bf7 100644 --- a/crates/rome_js_formatter/src/js/bindings/formal_parameter.rs +++ b/crates/rome_js_formatter/src/js/bindings/formal_parameter.rs @@ -7,7 +7,7 @@ use rome_js_syntax::JsFormalParameter; use rome_js_syntax::JsFormalParameterFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsFormalParameter, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsFormalParameter, f: &mut JsFormatter) -> FormatResult<()> { let JsFormalParameterFields { binding, question_mark_token, diff --git a/crates/rome_js_formatter/src/js/bindings/identifier_binding.rs b/crates/rome_js_formatter/src/js/bindings/identifier_binding.rs index a06bfe8844d..5c020478d2c 100644 --- a/crates/rome_js_formatter/src/js/bindings/identifier_binding.rs +++ b/crates/rome_js_formatter/src/js/bindings/identifier_binding.rs @@ -5,7 +5,7 @@ use rome_js_syntax::JsIdentifierBinding; use rome_js_syntax::JsIdentifierBindingFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsIdentifierBinding, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsIdentifierBinding, f: &mut JsFormatter) -> FormatResult<()> { let JsIdentifierBindingFields { name_token } = node.as_fields(); write![f, [name_token.format()]] diff --git a/crates/rome_js_formatter/src/js/bindings/object_binding_pattern.rs b/crates/rome_js_formatter/src/js/bindings/object_binding_pattern.rs index 337f8aa1226..a5d1e59aca2 100644 --- a/crates/rome_js_formatter/src/js/bindings/object_binding_pattern.rs +++ b/crates/rome_js_formatter/src/js/bindings/object_binding_pattern.rs @@ -5,7 +5,7 @@ use rome_js_syntax::JsObjectBindingPattern; use rome_js_syntax::JsObjectBindingPatternFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsObjectBindingPattern, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsObjectBindingPattern, f: &mut JsFormatter) -> FormatResult<()> { let JsObjectBindingPatternFields { l_curly_token, properties, diff --git a/crates/rome_js_formatter/src/js/bindings/object_binding_pattern_property.rs b/crates/rome_js_formatter/src/js/bindings/object_binding_pattern_property.rs index c2174ebba6e..f8225385ed9 100644 --- a/crates/rome_js_formatter/src/js/bindings/object_binding_pattern_property.rs +++ b/crates/rome_js_formatter/src/js/bindings/object_binding_pattern_property.rs @@ -1,4 +1,5 @@ use crate::prelude::*; +use crate::utils::FormatMemberName; use crate::FormatNodeFields; use rome_formatter::write; use rome_js_syntax::JsObjectBindingPatternProperty; @@ -7,10 +8,7 @@ use rome_js_syntax::JsObjectBindingPatternPropertyFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields( - node: &JsObjectBindingPatternProperty, - f: &mut JsFormatter, - ) -> FormatResult<()> { + fn fmt_fields(node: &JsObjectBindingPatternProperty, f: &mut JsFormatter) -> FormatResult<()> { let JsObjectBindingPatternPropertyFields { member, colon_token, @@ -21,7 +19,7 @@ impl FormatNodeFields write![ f, [ - member.format(), + FormatMemberName::from(member?), colon_token.format(), space_token(), pattern.format(), diff --git a/crates/rome_js_formatter/src/js/bindings/object_binding_pattern_rest.rs b/crates/rome_js_formatter/src/js/bindings/object_binding_pattern_rest.rs index 9c45807f22f..4520866c784 100644 --- a/crates/rome_js_formatter/src/js/bindings/object_binding_pattern_rest.rs +++ b/crates/rome_js_formatter/src/js/bindings/object_binding_pattern_rest.rs @@ -5,7 +5,7 @@ use rome_js_syntax::JsObjectBindingPatternRest; use rome_js_syntax::JsObjectBindingPatternRestFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsObjectBindingPatternRest, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsObjectBindingPatternRest, f: &mut JsFormatter) -> FormatResult<()> { let JsObjectBindingPatternRestFields { dotdotdot_token, binding, diff --git a/crates/rome_js_formatter/src/js/bindings/object_binding_pattern_shorthand_property.rs b/crates/rome_js_formatter/src/js/bindings/object_binding_pattern_shorthand_property.rs index 0403549439f..5162154b3db 100644 --- a/crates/rome_js_formatter/src/js/bindings/object_binding_pattern_shorthand_property.rs +++ b/crates/rome_js_formatter/src/js/bindings/object_binding_pattern_shorthand_property.rs @@ -7,7 +7,7 @@ use rome_js_syntax::JsObjectBindingPatternShorthandPropertyFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields( + fn fmt_fields( node: &JsObjectBindingPatternShorthandProperty, f: &mut JsFormatter, ) -> FormatResult<()> { diff --git a/crates/rome_js_formatter/src/js/bindings/parameters.rs b/crates/rome_js_formatter/src/js/bindings/parameters.rs index d41aeb46174..debcdaa228e 100644 --- a/crates/rome_js_formatter/src/js/bindings/parameters.rs +++ b/crates/rome_js_formatter/src/js/bindings/parameters.rs @@ -5,7 +5,7 @@ use rome_js_syntax::JsParameters; use rome_js_syntax::JsParametersFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsParameters, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsParameters, f: &mut JsFormatter) -> FormatResult<()> { let JsParametersFields { l_paren_token, items, diff --git a/crates/rome_js_formatter/src/js/bindings/rest_parameter.rs b/crates/rome_js_formatter/src/js/bindings/rest_parameter.rs index 100f18677a7..ba575c7c514 100644 --- a/crates/rome_js_formatter/src/js/bindings/rest_parameter.rs +++ b/crates/rome_js_formatter/src/js/bindings/rest_parameter.rs @@ -5,7 +5,7 @@ use rome_js_syntax::JsRestParameter; use rome_js_syntax::JsRestParameterFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsRestParameter, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsRestParameter, f: &mut JsFormatter) -> FormatResult<()> { let JsRestParameterFields { dotdotdot_token, binding, diff --git a/crates/rome_js_formatter/src/js/classes/constructor_class_member.rs b/crates/rome_js_formatter/src/js/classes/constructor_class_member.rs index a7e72644138..008e95807ba 100644 --- a/crates/rome_js_formatter/src/js/classes/constructor_class_member.rs +++ b/crates/rome_js_formatter/src/js/classes/constructor_class_member.rs @@ -1,11 +1,12 @@ use crate::prelude::*; +use crate::utils::FormatMemberName; use crate::FormatNodeFields; use rome_formatter::write; use rome_js_syntax::JsConstructorClassMember; use rome_js_syntax::JsConstructorClassMemberFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsConstructorClassMember, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsConstructorClassMember, f: &mut JsFormatter) -> FormatResult<()> { let JsConstructorClassMemberFields { modifiers, name, @@ -18,7 +19,7 @@ impl FormatNodeFields for FormatNodeRule for FormatNodeRule { - fn format_fields(node: &JsEmptyClassMember, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsEmptyClassMember, f: &mut JsFormatter) -> FormatResult<()> { let JsEmptyClassMemberFields { semicolon_token } = node.as_fields(); write!(f, [format_replaced(&semicolon_token?, &empty_element())]) diff --git a/crates/rome_js_formatter/src/js/classes/extends_clause.rs b/crates/rome_js_formatter/src/js/classes/extends_clause.rs index 8a43ed65699..0b9fbceec66 100644 --- a/crates/rome_js_formatter/src/js/classes/extends_clause.rs +++ b/crates/rome_js_formatter/src/js/classes/extends_clause.rs @@ -5,7 +5,7 @@ use rome_js_syntax::JsExtendsClause; use rome_js_syntax::JsExtendsClauseFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsExtendsClause, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsExtendsClause, f: &mut JsFormatter) -> FormatResult<()> { let JsExtendsClauseFields { extends_token, super_class, diff --git a/crates/rome_js_formatter/src/js/classes/getter_class_member.rs b/crates/rome_js_formatter/src/js/classes/getter_class_member.rs index b5fabb48848..e2986bbb0bd 100644 --- a/crates/rome_js_formatter/src/js/classes/getter_class_member.rs +++ b/crates/rome_js_formatter/src/js/classes/getter_class_member.rs @@ -1,11 +1,12 @@ use crate::prelude::*; +use crate::utils::FormatMemberName; use crate::FormatNodeFields; use rome_formatter::write; use rome_js_syntax::JsGetterClassMember; use rome_js_syntax::JsGetterClassMemberFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsGetterClassMember, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsGetterClassMember, f: &mut JsFormatter) -> FormatResult<()> { let JsGetterClassMemberFields { modifiers, get_token, @@ -23,7 +24,7 @@ impl FormatNodeFields for FormatNodeRule for FormatNodeRule { - fn format_fields(node: &JsMethodClassMember, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsMethodClassMember, f: &mut JsFormatter) -> FormatResult<()> { let JsMethodClassMemberFields { modifiers, async_token, @@ -28,7 +29,7 @@ impl FormatNodeFields for FormatNodeRule for FormatNodeRule { - fn format_fields(node: &JsPropertyClassMember, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsPropertyClassMember, f: &mut JsFormatter) -> FormatResult<()> { let JsPropertyClassMemberFields { modifiers, name, @@ -22,7 +22,7 @@ impl FormatNodeFields for FormatNodeRule for FormatNodeRule { - fn format_fields(node: &JsSetterClassMember, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsSetterClassMember, f: &mut JsFormatter) -> FormatResult<()> { let JsSetterClassMemberFields { modifiers, set_token, @@ -23,7 +24,7 @@ impl FormatNodeFields for FormatNodeRule for FormatNodeRule { - fn format_fields( + fn fmt_fields( node: &JsStaticInitializationBlockClassMember, f: &mut JsFormatter, ) -> FormatResult<()> { diff --git a/crates/rome_js_formatter/src/js/declarations/catch_declaration.rs b/crates/rome_js_formatter/src/js/declarations/catch_declaration.rs index c8d486c6435..6280ddf0051 100644 --- a/crates/rome_js_formatter/src/js/declarations/catch_declaration.rs +++ b/crates/rome_js_formatter/src/js/declarations/catch_declaration.rs @@ -5,7 +5,7 @@ use rome_js_syntax::JsCatchDeclaration; use rome_js_syntax::JsCatchDeclarationFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsCatchDeclaration, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsCatchDeclaration, f: &mut JsFormatter) -> FormatResult<()> { let JsCatchDeclarationFields { l_paren_token, binding, @@ -17,7 +17,7 @@ impl FormatNodeFields for FormatNodeRule f, [format_delimited( &l_paren_token?, - format_args![binding.format(), type_annotation.format()], + &format_args![binding.format(), type_annotation.format()], &r_paren_token?, ) .soft_block_indent()] diff --git a/crates/rome_js_formatter/src/js/declarations/class_declaration.rs b/crates/rome_js_formatter/src/js/declarations/class_declaration.rs index acb792089f7..606f8a27e08 100644 --- a/crates/rome_js_formatter/src/js/declarations/class_declaration.rs +++ b/crates/rome_js_formatter/src/js/declarations/class_declaration.rs @@ -4,7 +4,7 @@ use rome_formatter::write; use rome_js_syntax::{JsAnyClass, JsClassDeclaration}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsClassDeclaration, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsClassDeclaration, f: &mut JsFormatter) -> FormatResult<()> { write![f, [JsAnyClass::from(node.clone()).format()]] } } diff --git a/crates/rome_js_formatter/src/js/declarations/class_export_default_declaration.rs b/crates/rome_js_formatter/src/js/declarations/class_export_default_declaration.rs index 2f4313ede3a..d19ac851e44 100644 --- a/crates/rome_js_formatter/src/js/declarations/class_export_default_declaration.rs +++ b/crates/rome_js_formatter/src/js/declarations/class_export_default_declaration.rs @@ -7,10 +7,7 @@ use rome_js_syntax::JsClassExportDefaultDeclaration; impl FormatNodeFields for FormatNodeRule { - fn format_fields( - node: &JsClassExportDefaultDeclaration, - f: &mut JsFormatter, - ) -> FormatResult<()> { + fn fmt_fields(node: &JsClassExportDefaultDeclaration, f: &mut JsFormatter) -> FormatResult<()> { write![f, [JsAnyClass::from(node.clone()).format()]] } } diff --git a/crates/rome_js_formatter/src/js/declarations/for_variable_declaration.rs b/crates/rome_js_formatter/src/js/declarations/for_variable_declaration.rs index d05a14ceb48..703bfd903fd 100644 --- a/crates/rome_js_formatter/src/js/declarations/for_variable_declaration.rs +++ b/crates/rome_js_formatter/src/js/declarations/for_variable_declaration.rs @@ -5,7 +5,7 @@ use rome_js_syntax::JsForVariableDeclaration; use rome_js_syntax::JsForVariableDeclarationFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsForVariableDeclaration, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsForVariableDeclaration, f: &mut JsFormatter) -> FormatResult<()> { let JsForVariableDeclarationFields { kind_token, declarator, diff --git a/crates/rome_js_formatter/src/js/declarations/function_declaration.rs b/crates/rome_js_formatter/src/js/declarations/function_declaration.rs index 517bba6bfaa..0260cd20d6c 100644 --- a/crates/rome_js_formatter/src/js/declarations/function_declaration.rs +++ b/crates/rome_js_formatter/src/js/declarations/function_declaration.rs @@ -4,7 +4,7 @@ use rome_formatter::write; use rome_js_syntax::{JsAnyFunction, JsFunctionDeclaration}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsFunctionDeclaration, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsFunctionDeclaration, f: &mut JsFormatter) -> FormatResult<()> { write![f, [JsAnyFunction::from(node.clone()).format()]] } } diff --git a/crates/rome_js_formatter/src/js/declarations/function_export_default_declaration.rs b/crates/rome_js_formatter/src/js/declarations/function_export_default_declaration.rs index c1e09807bb0..231c8baa6bf 100644 --- a/crates/rome_js_formatter/src/js/declarations/function_export_default_declaration.rs +++ b/crates/rome_js_formatter/src/js/declarations/function_export_default_declaration.rs @@ -8,7 +8,7 @@ use rome_js_syntax::JsFunctionExportDefaultDeclaration; impl FormatNodeFields for FormatNodeRule { - fn format_fields( + fn fmt_fields( node: &JsFunctionExportDefaultDeclaration, f: &mut JsFormatter, ) -> FormatResult<()> { diff --git a/crates/rome_js_formatter/src/js/declarations/variable_declaration.rs b/crates/rome_js_formatter/src/js/declarations/variable_declaration.rs index e2d60e91f0b..a6774ba9c3c 100644 --- a/crates/rome_js_formatter/src/js/declarations/variable_declaration.rs +++ b/crates/rome_js_formatter/src/js/declarations/variable_declaration.rs @@ -6,7 +6,7 @@ use rome_js_syntax::JsVariableDeclaration; use rome_js_syntax::JsVariableDeclarationFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsVariableDeclaration, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsVariableDeclaration, f: &mut JsFormatter) -> FormatResult<()> { let JsVariableDeclarationFields { kind, declarators } = node.as_fields(); write![f, [kind.format(), space_token(), declarators.format(),]] diff --git a/crates/rome_js_formatter/src/js/expressions/array_expression.rs b/crates/rome_js_formatter/src/js/expressions/array_expression.rs index 83a2b961bdb..000db959cc3 100644 --- a/crates/rome_js_formatter/src/js/expressions/array_expression.rs +++ b/crates/rome_js_formatter/src/js/expressions/array_expression.rs @@ -6,7 +6,7 @@ use rome_js_syntax::JsArrayExpression; use rome_js_syntax::JsArrayExpressionFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsArrayExpression, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsArrayExpression, f: &mut JsFormatter) -> FormatResult<()> { let JsArrayExpressionFields { l_brack_token, elements, diff --git a/crates/rome_js_formatter/src/js/expressions/arrow_function_expression.rs b/crates/rome_js_formatter/src/js/expressions/arrow_function_expression.rs index 55d4778cda1..4b88f250eed 100644 --- a/crates/rome_js_formatter/src/js/expressions/arrow_function_expression.rs +++ b/crates/rome_js_formatter/src/js/expressions/arrow_function_expression.rs @@ -5,7 +5,7 @@ use crate::FormatNodeFields; use rome_js_syntax::{JsAnyFunction, JsArrowFunctionExpression}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsArrowFunctionExpression, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsArrowFunctionExpression, f: &mut JsFormatter) -> FormatResult<()> { write![f, [JsAnyFunction::from(node.clone()).format()]] } } diff --git a/crates/rome_js_formatter/src/js/expressions/assignment_expression.rs b/crates/rome_js_formatter/src/js/expressions/assignment_expression.rs index 4e383b325dc..6486f5c8fce 100644 --- a/crates/rome_js_formatter/src/js/expressions/assignment_expression.rs +++ b/crates/rome_js_formatter/src/js/expressions/assignment_expression.rs @@ -5,7 +5,7 @@ use rome_js_syntax::JsAssignmentExpression; use rome_js_syntax::JsAssignmentExpressionFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsAssignmentExpression, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsAssignmentExpression, f: &mut JsFormatter) -> FormatResult<()> { let JsAssignmentExpressionFields { left, operator_token, @@ -14,12 +14,12 @@ impl FormatNodeFields for FormatNodeRule for FormatNodeRule { - fn format_fields(node: &JsAwaitExpression, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsAwaitExpression, f: &mut JsFormatter) -> FormatResult<()> { let JsAwaitExpressionFields { await_token, argument, diff --git a/crates/rome_js_formatter/src/js/expressions/big_int_literal_expression.rs b/crates/rome_js_formatter/src/js/expressions/big_int_literal_expression.rs index 18daae09454..fbc4b0d6ff6 100644 --- a/crates/rome_js_formatter/src/js/expressions/big_int_literal_expression.rs +++ b/crates/rome_js_formatter/src/js/expressions/big_int_literal_expression.rs @@ -9,7 +9,7 @@ use rome_js_syntax::JsBigIntLiteralExpression; use rome_js_syntax::JsBigIntLiteralExpressionFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsBigIntLiteralExpression, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsBigIntLiteralExpression, f: &mut JsFormatter) -> FormatResult<()> { let JsBigIntLiteralExpressionFields { value_token } = node.as_fields(); let value_token = value_token?; diff --git a/crates/rome_js_formatter/src/js/expressions/binary_expression.rs b/crates/rome_js_formatter/src/js/expressions/binary_expression.rs index 82a2fe92dc0..4573e892979 100644 --- a/crates/rome_js_formatter/src/js/expressions/binary_expression.rs +++ b/crates/rome_js_formatter/src/js/expressions/binary_expression.rs @@ -5,7 +5,7 @@ use crate::FormatNodeFields; use rome_js_syntax::JsBinaryExpression; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsBinaryExpression, formatter: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsBinaryExpression, formatter: &mut JsFormatter) -> FormatResult<()> { format_binary_like_expression( JsAnyBinaryLikeExpression::JsBinaryExpression(node.clone()), formatter, diff --git a/crates/rome_js_formatter/src/js/expressions/boolean_literal_expression.rs b/crates/rome_js_formatter/src/js/expressions/boolean_literal_expression.rs index c681d0d0e6e..995ceac4579 100644 --- a/crates/rome_js_formatter/src/js/expressions/boolean_literal_expression.rs +++ b/crates/rome_js_formatter/src/js/expressions/boolean_literal_expression.rs @@ -5,7 +5,7 @@ use rome_js_syntax::JsBooleanLiteralExpression; use rome_js_syntax::JsBooleanLiteralExpressionFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsBooleanLiteralExpression, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsBooleanLiteralExpression, f: &mut JsFormatter) -> FormatResult<()> { let JsBooleanLiteralExpressionFields { value_token } = node.as_fields(); write![f, [value_token.format()]] diff --git a/crates/rome_js_formatter/src/js/expressions/call_arguments.rs b/crates/rome_js_formatter/src/js/expressions/call_arguments.rs index f7f59952200..363ae57646c 100644 --- a/crates/rome_js_formatter/src/js/expressions/call_arguments.rs +++ b/crates/rome_js_formatter/src/js/expressions/call_arguments.rs @@ -7,7 +7,7 @@ use rome_js_syntax::{JsAnyCallArgument, JsCallArguments}; use rome_rowan::{AstSeparatedList, SyntaxResult}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsCallArguments, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsCallArguments, f: &mut JsFormatter) -> FormatResult<()> { let JsCallArgumentsFields { l_paren_token, args, diff --git a/crates/rome_js_formatter/src/js/expressions/call_expression.rs b/crates/rome_js_formatter/src/js/expressions/call_expression.rs index 115716b15be..20d8e7b90ec 100644 --- a/crates/rome_js_formatter/src/js/expressions/call_expression.rs +++ b/crates/rome_js_formatter/src/js/expressions/call_expression.rs @@ -6,7 +6,7 @@ use rome_js_syntax::JsCallExpression; use rome_rowan::AstNode; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsCallExpression, formatter: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsCallExpression, formatter: &mut JsFormatter) -> FormatResult<()> { format_call_expression(node.syntax(), formatter) } } diff --git a/crates/rome_js_formatter/src/js/expressions/class_expression.rs b/crates/rome_js_formatter/src/js/expressions/class_expression.rs index b33281d7d6d..7d2c37132cd 100644 --- a/crates/rome_js_formatter/src/js/expressions/class_expression.rs +++ b/crates/rome_js_formatter/src/js/expressions/class_expression.rs @@ -4,7 +4,7 @@ use rome_formatter::write; use rome_js_syntax::{JsAnyClass, JsClassExpression}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsClassExpression, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsClassExpression, f: &mut JsFormatter) -> FormatResult<()> { write![f, [JsAnyClass::from(node.clone()).format()]] } } diff --git a/crates/rome_js_formatter/src/js/expressions/computed_member_expression.rs b/crates/rome_js_formatter/src/js/expressions/computed_member_expression.rs index 489faf35717..a49180fb62c 100644 --- a/crates/rome_js_formatter/src/js/expressions/computed_member_expression.rs +++ b/crates/rome_js_formatter/src/js/expressions/computed_member_expression.rs @@ -6,7 +6,7 @@ use rome_js_syntax::JsComputedMemberExpressionFields; use rome_rowan::AstNode; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsComputedMemberExpression, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsComputedMemberExpression, f: &mut JsFormatter) -> FormatResult<()> { let mut current = node.clone(); // Find the left most computed expression @@ -29,11 +29,11 @@ impl FormatNodeFields for FormatNodeRule for FormatNodeRule for FormatNodeRule { - fn format_fields( - node: &JsConditionalExpression, - formatter: &mut JsFormatter, - ) -> FormatResult<()> { + fn fmt_fields(node: &JsConditionalExpression, formatter: &mut JsFormatter) -> FormatResult<()> { format_conditional(&Conditional::Expression(node.clone()), formatter, false) } } diff --git a/crates/rome_js_formatter/src/js/expressions/function_expression.rs b/crates/rome_js_formatter/src/js/expressions/function_expression.rs index 1bcfdc623b6..9af451ffcad 100644 --- a/crates/rome_js_formatter/src/js/expressions/function_expression.rs +++ b/crates/rome_js_formatter/src/js/expressions/function_expression.rs @@ -4,7 +4,7 @@ use rome_formatter::write; use rome_js_syntax::{JsAnyFunction, JsFunctionExpression}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsFunctionExpression, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsFunctionExpression, f: &mut JsFormatter) -> FormatResult<()> { write![f, [JsAnyFunction::from(node.clone()).format()]] } } diff --git a/crates/rome_js_formatter/src/js/expressions/identifier_expression.rs b/crates/rome_js_formatter/src/js/expressions/identifier_expression.rs index 309f040f308..1e4f071002a 100644 --- a/crates/rome_js_formatter/src/js/expressions/identifier_expression.rs +++ b/crates/rome_js_formatter/src/js/expressions/identifier_expression.rs @@ -5,7 +5,7 @@ use rome_js_syntax::JsIdentifierExpression; use rome_js_syntax::JsIdentifierExpressionFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsIdentifierExpression, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsIdentifierExpression, f: &mut JsFormatter) -> FormatResult<()> { let JsIdentifierExpressionFields { name } = node.as_fields(); write![f, [name.format()]] diff --git a/crates/rome_js_formatter/src/js/expressions/import_call_expression.rs b/crates/rome_js_formatter/src/js/expressions/import_call_expression.rs index b1c5a5c1319..e0180804e05 100644 --- a/crates/rome_js_formatter/src/js/expressions/import_call_expression.rs +++ b/crates/rome_js_formatter/src/js/expressions/import_call_expression.rs @@ -5,7 +5,7 @@ use rome_js_syntax::JsImportCallExpression; use rome_js_syntax::JsImportCallExpressionFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsImportCallExpression, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsImportCallExpression, f: &mut JsFormatter) -> FormatResult<()> { let JsImportCallExpressionFields { import_token, arguments, diff --git a/crates/rome_js_formatter/src/js/expressions/in_expression.rs b/crates/rome_js_formatter/src/js/expressions/in_expression.rs index 0baa276201d..ce054590a1f 100644 --- a/crates/rome_js_formatter/src/js/expressions/in_expression.rs +++ b/crates/rome_js_formatter/src/js/expressions/in_expression.rs @@ -5,7 +5,7 @@ use crate::FormatNodeFields; use rome_js_syntax::JsInExpression; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsInExpression, formatter: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsInExpression, formatter: &mut JsFormatter) -> FormatResult<()> { format_binary_like_expression( JsAnyBinaryLikeExpression::JsInExpression(node.clone()), formatter, diff --git a/crates/rome_js_formatter/src/js/expressions/instanceof_expression.rs b/crates/rome_js_formatter/src/js/expressions/instanceof_expression.rs index 5875e185a56..233fdef199a 100644 --- a/crates/rome_js_formatter/src/js/expressions/instanceof_expression.rs +++ b/crates/rome_js_formatter/src/js/expressions/instanceof_expression.rs @@ -5,10 +5,7 @@ use crate::FormatNodeFields; use rome_js_syntax::JsInstanceofExpression; impl FormatNodeFields for FormatNodeRule { - fn format_fields( - node: &JsInstanceofExpression, - formatter: &mut JsFormatter, - ) -> FormatResult<()> { + fn fmt_fields(node: &JsInstanceofExpression, formatter: &mut JsFormatter) -> FormatResult<()> { format_binary_like_expression( JsAnyBinaryLikeExpression::JsInstanceofExpression(node.clone()), formatter, diff --git a/crates/rome_js_formatter/src/js/expressions/logical_expression.rs b/crates/rome_js_formatter/src/js/expressions/logical_expression.rs index a3d3efb9b0d..fa071765936 100644 --- a/crates/rome_js_formatter/src/js/expressions/logical_expression.rs +++ b/crates/rome_js_formatter/src/js/expressions/logical_expression.rs @@ -5,7 +5,7 @@ use crate::FormatNodeFields; use rome_js_syntax::JsLogicalExpression; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsLogicalExpression, formatter: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsLogicalExpression, formatter: &mut JsFormatter) -> FormatResult<()> { format_binary_like_expression( JsAnyBinaryLikeExpression::JsLogicalExpression(node.clone()), formatter, diff --git a/crates/rome_js_formatter/src/js/expressions/new_expression.rs b/crates/rome_js_formatter/src/js/expressions/new_expression.rs index e8a505e5984..746ea769ab1 100644 --- a/crates/rome_js_formatter/src/js/expressions/new_expression.rs +++ b/crates/rome_js_formatter/src/js/expressions/new_expression.rs @@ -5,7 +5,7 @@ use rome_js_syntax::JsNewExpression; use rome_js_syntax::JsNewExpressionFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsNewExpression, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsNewExpression, f: &mut JsFormatter) -> FormatResult<()> { let JsNewExpressionFields { new_token, callee, diff --git a/crates/rome_js_formatter/src/js/expressions/null_literal_expression.rs b/crates/rome_js_formatter/src/js/expressions/null_literal_expression.rs index dd0f006ee17..6b678d35c48 100644 --- a/crates/rome_js_formatter/src/js/expressions/null_literal_expression.rs +++ b/crates/rome_js_formatter/src/js/expressions/null_literal_expression.rs @@ -5,7 +5,7 @@ use rome_js_syntax::JsNullLiteralExpression; use rome_js_syntax::JsNullLiteralExpressionFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsNullLiteralExpression, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsNullLiteralExpression, f: &mut JsFormatter) -> FormatResult<()> { let JsNullLiteralExpressionFields { value_token } = node.as_fields(); write![f, [value_token.format()]] diff --git a/crates/rome_js_formatter/src/js/expressions/number_literal_expression.rs b/crates/rome_js_formatter/src/js/expressions/number_literal_expression.rs index 268fe10fe79..09b3aa6d262 100644 --- a/crates/rome_js_formatter/src/js/expressions/number_literal_expression.rs +++ b/crates/rome_js_formatter/src/js/expressions/number_literal_expression.rs @@ -5,7 +5,7 @@ use rome_js_syntax::JsNumberLiteralExpression; use rome_js_syntax::JsNumberLiteralExpressionFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsNumberLiteralExpression, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsNumberLiteralExpression, f: &mut JsFormatter) -> FormatResult<()> { let JsNumberLiteralExpressionFields { value_token } = node.as_fields(); write![f, [value_token.format()]] diff --git a/crates/rome_js_formatter/src/js/expressions/object_expression.rs b/crates/rome_js_formatter/src/js/expressions/object_expression.rs index 4e82a537184..505973857a0 100644 --- a/crates/rome_js_formatter/src/js/expressions/object_expression.rs +++ b/crates/rome_js_formatter/src/js/expressions/object_expression.rs @@ -6,7 +6,7 @@ use rome_js_syntax::JsObjectExpression; use rome_js_syntax::JsObjectExpressionFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsObjectExpression, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsObjectExpression, f: &mut JsFormatter) -> FormatResult<()> { let JsObjectExpressionFields { l_curly_token, members, diff --git a/crates/rome_js_formatter/src/js/expressions/parenthesized_expression.rs b/crates/rome_js_formatter/src/js/expressions/parenthesized_expression.rs index bfff2a5425d..2e3442b1c95 100644 --- a/crates/rome_js_formatter/src/js/expressions/parenthesized_expression.rs +++ b/crates/rome_js_formatter/src/js/expressions/parenthesized_expression.rs @@ -10,7 +10,7 @@ use rome_js_syntax::{ use rome_rowan::{AstNode, SyntaxResult}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsParenthesizedExpression, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsParenthesizedExpression, f: &mut JsFormatter) -> FormatResult<()> { let JsParenthesizedExpressionFields { l_paren_token, expression, @@ -41,7 +41,7 @@ impl FormatNodeFields for FormatNodeRule for FormatNodeRule { - fn format_fields(node: &JsPostUpdateExpression, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsPostUpdateExpression, f: &mut JsFormatter) -> FormatResult<()> { let JsPostUpdateExpressionFields { operand, operator_token, diff --git a/crates/rome_js_formatter/src/js/expressions/pre_update_expression.rs b/crates/rome_js_formatter/src/js/expressions/pre_update_expression.rs index aaa4f6b87c4..21aa201c496 100644 --- a/crates/rome_js_formatter/src/js/expressions/pre_update_expression.rs +++ b/crates/rome_js_formatter/src/js/expressions/pre_update_expression.rs @@ -6,7 +6,7 @@ use rome_js_syntax::JsPreUpdateExpression; use rome_js_syntax::JsPreUpdateExpressionFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsPreUpdateExpression, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsPreUpdateExpression, f: &mut JsFormatter) -> FormatResult<()> { let JsPreUpdateExpressionFields { operator_token, operand, diff --git a/crates/rome_js_formatter/src/js/expressions/regex_literal_expression.rs b/crates/rome_js_formatter/src/js/expressions/regex_literal_expression.rs index 385baaa0f7f..df38e9b46ef 100644 --- a/crates/rome_js_formatter/src/js/expressions/regex_literal_expression.rs +++ b/crates/rome_js_formatter/src/js/expressions/regex_literal_expression.rs @@ -7,7 +7,7 @@ use rome_js_syntax::JsRegexLiteralExpression; use rome_js_syntax::JsRegexLiteralExpressionFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsRegexLiteralExpression, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsRegexLiteralExpression, f: &mut JsFormatter) -> FormatResult<()> { let JsRegexLiteralExpressionFields { value_token } = node.as_fields(); let value_token = value_token?; let trimmed_raw_string = value_token.text_trimmed(); diff --git a/crates/rome_js_formatter/src/js/expressions/sequence_expression.rs b/crates/rome_js_formatter/src/js/expressions/sequence_expression.rs index 1f5d54a34cb..121cbfaadf2 100644 --- a/crates/rome_js_formatter/src/js/expressions/sequence_expression.rs +++ b/crates/rome_js_formatter/src/js/expressions/sequence_expression.rs @@ -6,7 +6,7 @@ use rome_js_syntax::{JsSequenceExpression, JsSequenceExpressionFields, JsSyntaxK use rome_rowan::AstNode; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsSequenceExpression, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsSequenceExpression, f: &mut JsFormatter) -> FormatResult<()> { let content = format_with(|f| { let mut current = node.clone(); let parent = current.syntax().parent(); @@ -78,7 +78,7 @@ impl FormatNodeFields for FormatNodeRule for FormatNodeRule for FormatNodeRule for FormatNodeRule { - fn format_fields(node: &JsStaticMemberExpression, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsStaticMemberExpression, f: &mut JsFormatter) -> FormatResult<()> { let mut current = node.clone(); while let Some(static_member_expression) = @@ -26,7 +26,7 @@ impl FormatNodeFields for FormatNodeRule for FormatNodeRule for FormatNodeRule { } impl Format for FormatMemberStaticExpression<'_> { - fn format(&self, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(&self, f: &mut JsFormatter) -> FormatResult<()> { let is_member_number_literal = self.is_number_literal_expression(); let object_has_trailing_trivia = self diff --git a/crates/rome_js_formatter/src/js/expressions/string_literal_expression.rs b/crates/rome_js_formatter/src/js/expressions/string_literal_expression.rs index 8afd9771dac..39634a97153 100644 --- a/crates/rome_js_formatter/src/js/expressions/string_literal_expression.rs +++ b/crates/rome_js_formatter/src/js/expressions/string_literal_expression.rs @@ -1,7 +1,7 @@ use crate::prelude::*; use rome_formatter::{write, Buffer, VecBuffer}; -use crate::utils::FormatLiteralStringToken; +use crate::utils::{FormatLiteralStringToken, StringLiteralParentKind}; use crate::FormatNodeFields; use rome_js_syntax::JsExpressionStatement; use rome_js_syntax::JsStringLiteralExpression; @@ -9,7 +9,7 @@ use rome_js_syntax::JsStringLiteralExpressionFields; use rome_rowan::AstNode; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsStringLiteralExpression, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsStringLiteralExpression, f: &mut JsFormatter) -> FormatResult<()> { let JsStringLiteralExpressionFields { value_token } = node.as_fields(); let value_token = value_token?; @@ -22,7 +22,10 @@ impl FormatNodeFields for FormatNodeRule for FormatNodeRule for FormatNodeRule { - fn format_fields(node: &JsSuperExpression, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsSuperExpression, f: &mut JsFormatter) -> FormatResult<()> { let JsSuperExpressionFields { super_token } = node.as_fields(); write![f, [super_token.format()]] diff --git a/crates/rome_js_formatter/src/js/expressions/template.rs b/crates/rome_js_formatter/src/js/expressions/template.rs index bdd41e13d33..2ce3c54bd9f 100644 --- a/crates/rome_js_formatter/src/js/expressions/template.rs +++ b/crates/rome_js_formatter/src/js/expressions/template.rs @@ -6,7 +6,7 @@ use rome_js_syntax::JsTemplate; use rome_js_syntax::JsTemplateFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsTemplate, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsTemplate, f: &mut JsFormatter) -> FormatResult<()> { let JsTemplateFields { tag, type_arguments, diff --git a/crates/rome_js_formatter/src/js/expressions/template_chunk_element.rs b/crates/rome_js_formatter/src/js/expressions/template_chunk_element.rs index 0019cbbf133..776dcd75965 100644 --- a/crates/rome_js_formatter/src/js/expressions/template_chunk_element.rs +++ b/crates/rome_js_formatter/src/js/expressions/template_chunk_element.rs @@ -5,10 +5,7 @@ use crate::FormatNodeFields; use rome_js_syntax::{JsTemplateChunkElement, JsTemplateChunkElementFields}; impl FormatNodeFields for FormatNodeRule { - fn format_fields( - node: &JsTemplateChunkElement, - formatter: &mut JsFormatter, - ) -> FormatResult<()> { + fn fmt_fields(node: &JsTemplateChunkElement, formatter: &mut JsFormatter) -> FormatResult<()> { let JsTemplateChunkElementFields { template_chunk_token, } = node.as_fields(); diff --git a/crates/rome_js_formatter/src/js/expressions/template_element.rs b/crates/rome_js_formatter/src/js/expressions/template_element.rs index 0a43848eafb..680dc15ddb9 100644 --- a/crates/rome_js_formatter/src/js/expressions/template_element.rs +++ b/crates/rome_js_formatter/src/js/expressions/template_element.rs @@ -4,7 +4,7 @@ use crate::FormatNodeFields; use rome_js_syntax::JsTemplateElement; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsTemplateElement, formatter: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsTemplateElement, formatter: &mut JsFormatter) -> FormatResult<()> { format_template_literal(TemplateElement::Js(node.clone()), formatter) } } diff --git a/crates/rome_js_formatter/src/js/expressions/this_expression.rs b/crates/rome_js_formatter/src/js/expressions/this_expression.rs index 284eea3e569..64ee57ba777 100644 --- a/crates/rome_js_formatter/src/js/expressions/this_expression.rs +++ b/crates/rome_js_formatter/src/js/expressions/this_expression.rs @@ -6,7 +6,7 @@ use rome_js_syntax::JsThisExpression; use rome_js_syntax::JsThisExpressionFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsThisExpression, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsThisExpression, f: &mut JsFormatter) -> FormatResult<()> { let JsThisExpressionFields { this_token } = node.as_fields(); write![f, [this_token.format()]] diff --git a/crates/rome_js_formatter/src/js/expressions/unary_expression.rs b/crates/rome_js_formatter/src/js/expressions/unary_expression.rs index 84c4db83454..8bd174bd265 100644 --- a/crates/rome_js_formatter/src/js/expressions/unary_expression.rs +++ b/crates/rome_js_formatter/src/js/expressions/unary_expression.rs @@ -8,7 +8,7 @@ use rome_js_syntax::{JsAnyExpression, JsUnaryExpression}; use rome_js_syntax::{JsUnaryExpressionFields, JsUnaryOperator}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsUnaryExpression, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsUnaryExpression, f: &mut JsFormatter) -> FormatResult<()> { let JsUnaryExpressionFields { operator_token, argument, @@ -69,9 +69,9 @@ impl FormatNodeFields for FormatNodeRule { f, [ operator_token.format(), - group_elements(format_args![ + group_elements(&format_args![ token("("), - soft_block_indent(argument.format()), + soft_block_indent(&argument.format()), token(")"), ]), ] diff --git a/crates/rome_js_formatter/src/js/expressions/yield_argument.rs b/crates/rome_js_formatter/src/js/expressions/yield_argument.rs index 41035080705..db1c732419c 100644 --- a/crates/rome_js_formatter/src/js/expressions/yield_argument.rs +++ b/crates/rome_js_formatter/src/js/expressions/yield_argument.rs @@ -6,7 +6,7 @@ use rome_js_syntax::JsYieldArgument; use rome_js_syntax::JsYieldArgumentFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsYieldArgument, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsYieldArgument, f: &mut JsFormatter) -> FormatResult<()> { let JsYieldArgumentFields { star_token, expression, diff --git a/crates/rome_js_formatter/src/js/expressions/yield_expression.rs b/crates/rome_js_formatter/src/js/expressions/yield_expression.rs index 48764e680e3..3f45cb5c6cb 100644 --- a/crates/rome_js_formatter/src/js/expressions/yield_expression.rs +++ b/crates/rome_js_formatter/src/js/expressions/yield_expression.rs @@ -6,7 +6,7 @@ use rome_js_syntax::JsYieldExpression; use rome_js_syntax::JsYieldExpressionFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsYieldExpression, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsYieldExpression, f: &mut JsFormatter) -> FormatResult<()> { let JsYieldExpressionFields { yield_token, argument, diff --git a/crates/rome_js_formatter/src/js/lists/array_assignment_pattern_element_list.rs b/crates/rome_js_formatter/src/js/lists/array_assignment_pattern_element_list.rs index a18313aaf5a..24840a57d94 100644 --- a/crates/rome_js_formatter/src/js/lists/array_assignment_pattern_element_list.rs +++ b/crates/rome_js_formatter/src/js/lists/array_assignment_pattern_element_list.rs @@ -1,15 +1,15 @@ use crate::generated::FormatJsArrayAssignmentPatternElementList; use crate::prelude::*; -use crate::utils::array::format_array_node; +use crate::utils::array::write_array_node; use rome_js_syntax::JsArrayAssignmentPatternElementList; impl FormatRule for FormatJsArrayAssignmentPatternElementList { type Context = JsFormatContext; - fn format( + fn fmt( node: &JsArrayAssignmentPatternElementList, formatter: &mut JsFormatter, ) -> FormatResult<()> { - format_array_node(node, formatter) + write_array_node(node, formatter) } } diff --git a/crates/rome_js_formatter/src/js/lists/array_binding_pattern_element_list.rs b/crates/rome_js_formatter/src/js/lists/array_binding_pattern_element_list.rs index 588e1d00426..390f4e06393 100644 --- a/crates/rome_js_formatter/src/js/lists/array_binding_pattern_element_list.rs +++ b/crates/rome_js_formatter/src/js/lists/array_binding_pattern_element_list.rs @@ -1,15 +1,15 @@ use crate::generated::FormatJsArrayBindingPatternElementList; use crate::prelude::*; -use crate::utils::array::format_array_node; +use crate::utils::array::write_array_node; use rome_js_syntax::JsArrayBindingPatternElementList; impl FormatRule for FormatJsArrayBindingPatternElementList { type Context = JsFormatContext; - fn format( + fn fmt( node: &JsArrayBindingPatternElementList, formatter: &mut JsFormatter, ) -> FormatResult<()> { - format_array_node(node, formatter) + write_array_node(node, formatter) } } diff --git a/crates/rome_js_formatter/src/js/lists/array_element_list.rs b/crates/rome_js_formatter/src/js/lists/array_element_list.rs index e67427785e5..dfd27189327 100644 --- a/crates/rome_js_formatter/src/js/lists/array_element_list.rs +++ b/crates/rome_js_formatter/src/js/lists/array_element_list.rs @@ -2,7 +2,7 @@ use crate::prelude::*; use rome_formatter::GroupId; use std::convert::Infallible; -use crate::utils::array::format_array_node; +use crate::utils::array::write_array_node; use crate::generated::FormatJsArrayElementList; use crate::utils::has_formatter_trivia; @@ -12,7 +12,7 @@ use rome_rowan::{AstNode, AstSeparatedList}; impl FormatRule for FormatJsArrayElementList { type Context = JsFormatContext; - fn format(node: &JsArrayElementList, formatter: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &JsArrayElementList, formatter: &mut JsFormatter) -> FormatResult<()> { Self::format_with_group_id(node, formatter, None) } } @@ -27,7 +27,7 @@ impl FormatJsArrayElementList { if !has_formatter_trivia(node.syntax()) && can_print_fill(node) { // Using format_separated is valid in this case as can_print_fill does not allow holes return f - .fill(&soft_line_break_or_space()) + .fill(soft_line_break_or_space()) .entries( node.format_separated(token(",")) .with_options(FormatSeparatedOptions::default().with_group_id(group_id)), @@ -35,7 +35,7 @@ impl FormatJsArrayElementList { .finish(); } - format_array_node(node, f) + write_array_node(node, f) } } diff --git a/crates/rome_js_formatter/src/js/lists/call_argument_list.rs b/crates/rome_js_formatter/src/js/lists/call_argument_list.rs index 7d7c8539da6..cade7805df6 100644 --- a/crates/rome_js_formatter/src/js/lists/call_argument_list.rs +++ b/crates/rome_js_formatter/src/js/lists/call_argument_list.rs @@ -5,8 +5,8 @@ use rome_js_syntax::JsCallArgumentList; impl FormatRule for FormatJsCallArgumentList { type Context = JsFormatContext; - fn format(node: &JsCallArgumentList, f: &mut JsFormatter) -> FormatResult<()> { - f.join_with(soft_line_break_or_space()) + fn fmt(node: &JsCallArgumentList, f: &mut JsFormatter) -> FormatResult<()> { + f.join_with(&soft_line_break_or_space()) .entries(node.format_separated(token(","))) .finish() } diff --git a/crates/rome_js_formatter/src/js/lists/class_member_list.rs b/crates/rome_js_formatter/src/js/lists/class_member_list.rs index 58c2a4df919..e6a4e3141fc 100644 --- a/crates/rome_js_formatter/src/js/lists/class_member_list.rs +++ b/crates/rome_js_formatter/src/js/lists/class_member_list.rs @@ -5,7 +5,7 @@ use rome_js_syntax::JsClassMemberList; impl FormatRule for FormatJsClassMemberList { type Context = JsFormatContext; - fn format(node: &JsClassMemberList, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &JsClassMemberList, f: &mut JsFormatter) -> FormatResult<()> { let mut join = f.join_nodes_with_hardline(); for member in node { diff --git a/crates/rome_js_formatter/src/js/lists/constructor_modifier_list.rs b/crates/rome_js_formatter/src/js/lists/constructor_modifier_list.rs index b406e1c6035..c294773a6de 100644 --- a/crates/rome_js_formatter/src/js/lists/constructor_modifier_list.rs +++ b/crates/rome_js_formatter/src/js/lists/constructor_modifier_list.rs @@ -6,8 +6,8 @@ use rome_rowan::AstNodeList; impl FormatRule for FormatJsConstructorModifierList { type Context = JsFormatContext; - fn format(node: &JsConstructorModifierList, f: &mut JsFormatter) -> FormatResult<()> { - f.join_with(space_token()) + fn fmt(node: &JsConstructorModifierList, f: &mut JsFormatter) -> FormatResult<()> { + f.join_with(&space_token()) .entries(node.iter().formatted()) .finish() } diff --git a/crates/rome_js_formatter/src/js/lists/constructor_parameter_list.rs b/crates/rome_js_formatter/src/js/lists/constructor_parameter_list.rs index 1f9ebc7c90c..d2d1e699d10 100644 --- a/crates/rome_js_formatter/src/js/lists/constructor_parameter_list.rs +++ b/crates/rome_js_formatter/src/js/lists/constructor_parameter_list.rs @@ -5,8 +5,8 @@ use rome_js_syntax::JsConstructorParameterList; impl FormatRule for FormatJsConstructorParameterList { type Context = JsFormatContext; - fn format(node: &JsConstructorParameterList, f: &mut JsFormatter) -> FormatResult<()> { - f.join_with(soft_line_break_or_space()) + fn fmt(node: &JsConstructorParameterList, f: &mut JsFormatter) -> FormatResult<()> { + f.join_with(&soft_line_break_or_space()) .entries(node.format_separated(token(","))) .finish() } diff --git a/crates/rome_js_formatter/src/js/lists/directive_list.rs b/crates/rome_js_formatter/src/js/lists/directive_list.rs index fcffa029c80..d5d1968974b 100644 --- a/crates/rome_js_formatter/src/js/lists/directive_list.rs +++ b/crates/rome_js_formatter/src/js/lists/directive_list.rs @@ -7,7 +7,7 @@ use rome_rowan::{AstNode, AstNodeList}; impl FormatRule for FormatJsDirectiveList { type Context = JsFormatContext; - fn format(node: &JsDirectiveList, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &JsDirectiveList, f: &mut JsFormatter) -> FormatResult<()> { if node.is_empty() { return Ok(()); } diff --git a/crates/rome_js_formatter/src/js/lists/export_named_from_specifier_list.rs b/crates/rome_js_formatter/src/js/lists/export_named_from_specifier_list.rs index 83ee4429543..04ec5536df4 100644 --- a/crates/rome_js_formatter/src/js/lists/export_named_from_specifier_list.rs +++ b/crates/rome_js_formatter/src/js/lists/export_named_from_specifier_list.rs @@ -5,8 +5,8 @@ use rome_js_syntax::JsExportNamedFromSpecifierList; impl FormatRule for FormatJsExportNamedFromSpecifierList { type Context = JsFormatContext; - fn format(node: &JsExportNamedFromSpecifierList, f: &mut JsFormatter) -> FormatResult<()> { - f.join_with(soft_line_break_or_space()) + fn fmt(node: &JsExportNamedFromSpecifierList, f: &mut JsFormatter) -> FormatResult<()> { + f.join_with(&soft_line_break_or_space()) .entries(node.format_separated(token(","))) .finish() } diff --git a/crates/rome_js_formatter/src/js/lists/export_named_specifier_list.rs b/crates/rome_js_formatter/src/js/lists/export_named_specifier_list.rs index 33a9d4a6d08..d7700cbf69a 100644 --- a/crates/rome_js_formatter/src/js/lists/export_named_specifier_list.rs +++ b/crates/rome_js_formatter/src/js/lists/export_named_specifier_list.rs @@ -5,8 +5,8 @@ use rome_js_syntax::JsExportNamedSpecifierList; impl FormatRule for FormatJsExportNamedSpecifierList { type Context = JsFormatContext; - fn format(node: &JsExportNamedSpecifierList, f: &mut JsFormatter) -> FormatResult<()> { - f.join_with(soft_line_break_or_space()) + fn fmt(node: &JsExportNamedSpecifierList, f: &mut JsFormatter) -> FormatResult<()> { + f.join_with(&soft_line_break_or_space()) .entries(node.format_separated(token(","))) .finish() } diff --git a/crates/rome_js_formatter/src/js/lists/import_assertion_entry_list.rs b/crates/rome_js_formatter/src/js/lists/import_assertion_entry_list.rs index 00b534db1d1..8c2a96d7711 100644 --- a/crates/rome_js_formatter/src/js/lists/import_assertion_entry_list.rs +++ b/crates/rome_js_formatter/src/js/lists/import_assertion_entry_list.rs @@ -5,8 +5,8 @@ use rome_js_syntax::JsImportAssertionEntryList; impl FormatRule for FormatJsImportAssertionEntryList { type Context = JsFormatContext; - fn format(node: &JsImportAssertionEntryList, f: &mut JsFormatter) -> FormatResult<()> { - f.join_with(soft_line_break_or_space()) + fn fmt(node: &JsImportAssertionEntryList, f: &mut JsFormatter) -> FormatResult<()> { + f.join_with(&soft_line_break_or_space()) .entries(node.format_separated(token(","))) .finish() } diff --git a/crates/rome_js_formatter/src/js/lists/method_modifier_list.rs b/crates/rome_js_formatter/src/js/lists/method_modifier_list.rs index 75685e9cb10..04d10182098 100644 --- a/crates/rome_js_formatter/src/js/lists/method_modifier_list.rs +++ b/crates/rome_js_formatter/src/js/lists/method_modifier_list.rs @@ -6,8 +6,8 @@ use rome_js_syntax::JsMethodModifierList; impl FormatRule for FormatJsMethodModifierList { type Context = JsFormatContext; - fn format(node: &JsMethodModifierList, f: &mut JsFormatter) -> FormatResult<()> { - f.join_with(space_token()) + fn fmt(node: &JsMethodModifierList, f: &mut JsFormatter) -> FormatResult<()> { + f.join_with(&space_token()) .entries(sort_modifiers_by_precedence(node).into_iter().formatted()) .finish() } diff --git a/crates/rome_js_formatter/src/js/lists/module_item_list.rs b/crates/rome_js_formatter/src/js/lists/module_item_list.rs index 90beaace4f8..5ce2fb97aa9 100644 --- a/crates/rome_js_formatter/src/js/lists/module_item_list.rs +++ b/crates/rome_js_formatter/src/js/lists/module_item_list.rs @@ -5,7 +5,7 @@ use rome_js_syntax::JsModuleItemList; impl FormatRule for FormatJsModuleItemList { type Context = JsFormatContext; - fn format(node: &JsModuleItemList, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &JsModuleItemList, f: &mut JsFormatter) -> FormatResult<()> { let mut join = f.join_nodes_with_hardline(); for module_item in node { diff --git a/crates/rome_js_formatter/src/js/lists/named_import_specifier_list.rs b/crates/rome_js_formatter/src/js/lists/named_import_specifier_list.rs index 79d9d2f46ac..71562503e20 100644 --- a/crates/rome_js_formatter/src/js/lists/named_import_specifier_list.rs +++ b/crates/rome_js_formatter/src/js/lists/named_import_specifier_list.rs @@ -5,8 +5,8 @@ use rome_js_syntax::JsNamedImportSpecifierList; impl FormatRule for FormatJsNamedImportSpecifierList { type Context = JsFormatContext; - fn format(node: &JsNamedImportSpecifierList, f: &mut JsFormatter) -> FormatResult<()> { - f.join_with(soft_line_break_or_space()) + fn fmt(node: &JsNamedImportSpecifierList, f: &mut JsFormatter) -> FormatResult<()> { + f.join_with(&soft_line_break_or_space()) .entries(node.format_separated(token(","))) .finish() } diff --git a/crates/rome_js_formatter/src/js/lists/object_assignment_pattern_property_list.rs b/crates/rome_js_formatter/src/js/lists/object_assignment_pattern_property_list.rs index d2ceb974ac9..3e0767811bb 100644 --- a/crates/rome_js_formatter/src/js/lists/object_assignment_pattern_property_list.rs +++ b/crates/rome_js_formatter/src/js/lists/object_assignment_pattern_property_list.rs @@ -7,10 +7,7 @@ impl FormatRule { type Context = JsFormatContext; - fn format( - node: &JsObjectAssignmentPatternPropertyList, - f: &mut JsFormatter, - ) -> FormatResult<()> { + fn fmt(node: &JsObjectAssignmentPatternPropertyList, f: &mut JsFormatter) -> FormatResult<()> { // The trailing separator is disallowed after a rest element let has_trailing_rest = match node.into_iter().last() { Some(elem) => matches!( @@ -26,7 +23,7 @@ impl FormatRule TrailingSeparator::Allowed }; - f.join_with(soft_line_break_or_space()) + f.join_with(&soft_line_break_or_space()) .entries(node.format_separated(token(",")).with_options( FormatSeparatedOptions::default().with_trailing_separator(trailing_separator), )) diff --git a/crates/rome_js_formatter/src/js/lists/object_binding_pattern_property_list.rs b/crates/rome_js_formatter/src/js/lists/object_binding_pattern_property_list.rs index 57478f0d7eb..5430bfe89d1 100644 --- a/crates/rome_js_formatter/src/js/lists/object_binding_pattern_property_list.rs +++ b/crates/rome_js_formatter/src/js/lists/object_binding_pattern_property_list.rs @@ -5,7 +5,7 @@ use rome_js_syntax::{JsAnyObjectBindingPatternMember, JsObjectBindingPatternProp impl FormatRule for FormatJsObjectBindingPatternPropertyList { type Context = JsFormatContext; - fn format(node: &JsObjectBindingPatternPropertyList, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &JsObjectBindingPatternPropertyList, f: &mut JsFormatter) -> FormatResult<()> { // The trailing separator is disallowed after a rest element let has_trailing_rest = match node.into_iter().last() { Some(elem) => matches!( @@ -21,7 +21,7 @@ impl FormatRule for FormatJsObjectBindingPat TrailingSeparator::Allowed }; - f.join_with(soft_line_break_or_space()) + f.join_with(&soft_line_break_or_space()) .entries(node.format_separated(token(",")).with_options( FormatSeparatedOptions::default().with_trailing_separator(trailing_separator), )) diff --git a/crates/rome_js_formatter/src/js/lists/object_member_list.rs b/crates/rome_js_formatter/src/js/lists/object_member_list.rs index 6bafe80629c..974425bd71f 100644 --- a/crates/rome_js_formatter/src/js/lists/object_member_list.rs +++ b/crates/rome_js_formatter/src/js/lists/object_member_list.rs @@ -6,7 +6,7 @@ use rome_rowan::{AstNode, AstSeparatedList}; impl FormatRule for FormatJsObjectMemberList { type Context = JsFormatContext; - fn format(node: &JsObjectMemberList, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &JsObjectMemberList, f: &mut JsFormatter) -> FormatResult<()> { let mut join = f.join_nodes_with_soft_line(); for (element, formatted) in node.elements().zip(node.format_separated(token(","))) { diff --git a/crates/rome_js_formatter/src/js/lists/parameter_list.rs b/crates/rome_js_formatter/src/js/lists/parameter_list.rs index b24a24783cc..4c07e877273 100644 --- a/crates/rome_js_formatter/src/js/lists/parameter_list.rs +++ b/crates/rome_js_formatter/src/js/lists/parameter_list.rs @@ -5,7 +5,7 @@ use rome_js_syntax::{JsAnyParameter, JsParameterList}; impl FormatRule for FormatJsParameterList { type Context = JsFormatContext; - fn format(node: &JsParameterList, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &JsParameterList, f: &mut JsFormatter) -> FormatResult<()> { // The trailing separator is disallowed if the last element in the list is a rest parameter let has_trailing_rest = match node.into_iter().last() { Some(elem) => matches!(elem?, JsAnyParameter::JsRestParameter(_)), @@ -18,7 +18,7 @@ impl FormatRule for FormatJsParameterList { TrailingSeparator::Allowed }; - f.join_with(soft_line_break_or_space()) + f.join_with(&soft_line_break_or_space()) .entries(node.format_separated(token(",")).with_options( FormatSeparatedOptions::default().with_trailing_separator(trailing_separator), )) diff --git a/crates/rome_js_formatter/src/js/lists/property_modifier_list.rs b/crates/rome_js_formatter/src/js/lists/property_modifier_list.rs index 23175d5edc0..5e7f3762978 100644 --- a/crates/rome_js_formatter/src/js/lists/property_modifier_list.rs +++ b/crates/rome_js_formatter/src/js/lists/property_modifier_list.rs @@ -6,8 +6,8 @@ use rome_js_syntax::JsPropertyModifierList; impl FormatRule for FormatJsPropertyModifierList { type Context = JsFormatContext; - fn format(node: &JsPropertyModifierList, f: &mut JsFormatter) -> FormatResult<()> { - f.join_with(space_token()) + fn fmt(node: &JsPropertyModifierList, f: &mut JsFormatter) -> FormatResult<()> { + f.join_with(&space_token()) .entries(sort_modifiers_by_precedence(node).into_iter().formatted()) .finish() } diff --git a/crates/rome_js_formatter/src/js/lists/statement_list.rs b/crates/rome_js_formatter/src/js/lists/statement_list.rs index 2ccf4804b38..d03a1ad39ba 100644 --- a/crates/rome_js_formatter/src/js/lists/statement_list.rs +++ b/crates/rome_js_formatter/src/js/lists/statement_list.rs @@ -5,7 +5,7 @@ use rome_js_syntax::JsStatementList; impl FormatRule for FormatJsStatementList { type Context = JsFormatContext; - fn format(node: &JsStatementList, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &JsStatementList, f: &mut JsFormatter) -> FormatResult<()> { let mut join = f.join_nodes_with_hardline(); for statement in node.iter() { diff --git a/crates/rome_js_formatter/src/js/lists/switch_case_list.rs b/crates/rome_js_formatter/src/js/lists/switch_case_list.rs index d7d6ecd5663..d755d7038c8 100644 --- a/crates/rome_js_formatter/src/js/lists/switch_case_list.rs +++ b/crates/rome_js_formatter/src/js/lists/switch_case_list.rs @@ -5,7 +5,7 @@ use rome_js_syntax::JsSwitchCaseList; impl FormatRule for FormatJsSwitchCaseList { type Context = JsFormatContext; - fn format(node: &JsSwitchCaseList, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &JsSwitchCaseList, f: &mut JsFormatter) -> FormatResult<()> { let mut join = f.join_nodes_with_hardline(); for case in node { diff --git a/crates/rome_js_formatter/src/js/lists/template_element_list.rs b/crates/rome_js_formatter/src/js/lists/template_element_list.rs index 292a38c52cf..cb8a21900fc 100644 --- a/crates/rome_js_formatter/src/js/lists/template_element_list.rs +++ b/crates/rome_js_formatter/src/js/lists/template_element_list.rs @@ -5,11 +5,11 @@ use rome_js_syntax::JsTemplateElementList; impl FormatRule for FormatJsTemplateElementList { type Context = JsFormatContext; - fn format(node: &JsTemplateElementList, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &JsTemplateElementList, f: &mut JsFormatter) -> FormatResult<()> { let mut join = f.join(); for element in node { - join.entry(&group_elements(element.format())); + join.entry(&group_elements(&element.format())); } join.finish() diff --git a/crates/rome_js_formatter/src/js/lists/variable_declarator_list.rs b/crates/rome_js_formatter/src/js/lists/variable_declarator_list.rs index c6e01624b4a..091330524bf 100644 --- a/crates/rome_js_formatter/src/js/lists/variable_declarator_list.rs +++ b/crates/rome_js_formatter/src/js/lists/variable_declarator_list.rs @@ -9,12 +9,12 @@ use rome_rowan::AstSeparatedList; impl FormatRule for FormatJsVariableDeclaratorList { type Context = JsFormatContext; - fn format(node: &JsVariableDeclaratorList, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &JsVariableDeclaratorList, f: &mut JsFormatter) -> FormatResult<()> { let last_index = node.len().saturating_sub(1); let mut declarators = node.elements().enumerate().map(|(index, element)| { format_with(move |f| { - write!(f, [group_elements(element.node().format())])?; + write!(f, [group_elements(&element.node().format())])?; match element.trailing_separator()? { None => { @@ -45,16 +45,16 @@ impl FormatRule for FormatJsVariableDeclaratorList { write!(f, [soft_line_break_or_space()])?; - f.join_with(soft_line_break_or_space()) + f.join_with(&soft_line_break_or_space()) .entries(declarators) .finish() }); write!( f, - [group_elements(format_args!( + [group_elements(&format_args!( leading_element, - indent(other_declarators) + indent(&other_declarators) ))] ) } diff --git a/crates/rome_js_formatter/src/js/module/default_import_specifier.rs b/crates/rome_js_formatter/src/js/module/default_import_specifier.rs index 2844b018db4..13bb48372a1 100644 --- a/crates/rome_js_formatter/src/js/module/default_import_specifier.rs +++ b/crates/rome_js_formatter/src/js/module/default_import_specifier.rs @@ -6,7 +6,7 @@ use rome_js_syntax::JsDefaultImportSpecifier; use rome_js_syntax::JsDefaultImportSpecifierFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsDefaultImportSpecifier, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsDefaultImportSpecifier, f: &mut JsFormatter) -> FormatResult<()> { let JsDefaultImportSpecifierFields { local_name, trailing_comma_token, diff --git a/crates/rome_js_formatter/src/js/module/export.rs b/crates/rome_js_formatter/src/js/module/export.rs index 5d188e3b62a..54be3d0d925 100644 --- a/crates/rome_js_formatter/src/js/module/export.rs +++ b/crates/rome_js_formatter/src/js/module/export.rs @@ -6,7 +6,7 @@ use rome_js_syntax::JsExport; use rome_js_syntax::JsExportFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsExport, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsExport, f: &mut JsFormatter) -> FormatResult<()> { let JsExportFields { export_token, export_clause, diff --git a/crates/rome_js_formatter/src/js/module/export_as_clause.rs b/crates/rome_js_formatter/src/js/module/export_as_clause.rs index 7ba16e05d44..8f2ca3e629c 100644 --- a/crates/rome_js_formatter/src/js/module/export_as_clause.rs +++ b/crates/rome_js_formatter/src/js/module/export_as_clause.rs @@ -6,7 +6,7 @@ use rome_js_syntax::JsExportAsClause; use rome_js_syntax::JsExportAsClauseFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsExportAsClause, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsExportAsClause, f: &mut JsFormatter) -> FormatResult<()> { let JsExportAsClauseFields { as_token, exported_name, diff --git a/crates/rome_js_formatter/src/js/module/export_default_declaration_clause.rs b/crates/rome_js_formatter/src/js/module/export_default_declaration_clause.rs index 4f7c8272449..9fb539aca1a 100644 --- a/crates/rome_js_formatter/src/js/module/export_default_declaration_clause.rs +++ b/crates/rome_js_formatter/src/js/module/export_default_declaration_clause.rs @@ -6,7 +6,7 @@ use rome_js_syntax::{JsExportDefaultDeclarationClause, JsExportDefaultDeclaratio impl FormatNodeFields for FormatNodeRule { - fn format_fields( + fn fmt_fields( node: &JsExportDefaultDeclarationClause, f: &mut JsFormatter, ) -> FormatResult<()> { diff --git a/crates/rome_js_formatter/src/js/module/export_default_expression_clause.rs b/crates/rome_js_formatter/src/js/module/export_default_expression_clause.rs index edc9ea5e87e..389c157bafd 100644 --- a/crates/rome_js_formatter/src/js/module/export_default_expression_clause.rs +++ b/crates/rome_js_formatter/src/js/module/export_default_expression_clause.rs @@ -9,10 +9,7 @@ use rome_js_syntax::JsExportDefaultExpressionClauseFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields( - node: &JsExportDefaultExpressionClause, - f: &mut JsFormatter, - ) -> FormatResult<()> { + fn fmt_fields(node: &JsExportDefaultExpressionClause, f: &mut JsFormatter) -> FormatResult<()> { let JsExportDefaultExpressionClauseFields { default_token, expression, diff --git a/crates/rome_js_formatter/src/js/module/export_from_clause.rs b/crates/rome_js_formatter/src/js/module/export_from_clause.rs index 25698da5302..ecfcd0b11f0 100644 --- a/crates/rome_js_formatter/src/js/module/export_from_clause.rs +++ b/crates/rome_js_formatter/src/js/module/export_from_clause.rs @@ -7,7 +7,7 @@ use rome_js_syntax::JsExportFromClause; use rome_js_syntax::JsExportFromClauseFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsExportFromClause, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsExportFromClause, f: &mut JsFormatter) -> FormatResult<()> { let JsExportFromClauseFields { star_token, export_as, diff --git a/crates/rome_js_formatter/src/js/module/export_named_clause.rs b/crates/rome_js_formatter/src/js/module/export_named_clause.rs index 36050406c02..4a0c8200955 100644 --- a/crates/rome_js_formatter/src/js/module/export_named_clause.rs +++ b/crates/rome_js_formatter/src/js/module/export_named_clause.rs @@ -7,7 +7,7 @@ use rome_js_syntax::JsExportNamedClause; use rome_js_syntax::JsExportNamedClauseFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsExportNamedClause, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsExportNamedClause, f: &mut JsFormatter) -> FormatResult<()> { let JsExportNamedClauseFields { type_token, l_curly_token, diff --git a/crates/rome_js_formatter/src/js/module/export_named_from_clause.rs b/crates/rome_js_formatter/src/js/module/export_named_from_clause.rs index 9d930652f8a..0aae763c557 100644 --- a/crates/rome_js_formatter/src/js/module/export_named_from_clause.rs +++ b/crates/rome_js_formatter/src/js/module/export_named_from_clause.rs @@ -8,7 +8,7 @@ use rome_js_syntax::JsExportNamedFromClauseFields; use rome_rowan::AstNode; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsExportNamedFromClause, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsExportNamedFromClause, f: &mut JsFormatter) -> FormatResult<()> { let JsExportNamedFromClauseFields { type_token, l_curly_token, diff --git a/crates/rome_js_formatter/src/js/module/export_named_from_specifier.rs b/crates/rome_js_formatter/src/js/module/export_named_from_specifier.rs index 2d3e91fea26..3b69631f1d4 100644 --- a/crates/rome_js_formatter/src/js/module/export_named_from_specifier.rs +++ b/crates/rome_js_formatter/src/js/module/export_named_from_specifier.rs @@ -6,7 +6,7 @@ use rome_js_syntax::JsExportNamedFromSpecifier; use rome_js_syntax::JsExportNamedFromSpecifierFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsExportNamedFromSpecifier, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsExportNamedFromSpecifier, f: &mut JsFormatter) -> FormatResult<()> { let JsExportNamedFromSpecifierFields { type_token, source_name, diff --git a/crates/rome_js_formatter/src/js/module/export_named_shorthand_specifier.rs b/crates/rome_js_formatter/src/js/module/export_named_shorthand_specifier.rs index 2d7700dae28..03345144f70 100644 --- a/crates/rome_js_formatter/src/js/module/export_named_shorthand_specifier.rs +++ b/crates/rome_js_formatter/src/js/module/export_named_shorthand_specifier.rs @@ -8,10 +8,7 @@ use rome_js_syntax::JsExportNamedShorthandSpecifierFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields( - node: &JsExportNamedShorthandSpecifier, - f: &mut JsFormatter, - ) -> FormatResult<()> { + fn fmt_fields(node: &JsExportNamedShorthandSpecifier, f: &mut JsFormatter) -> FormatResult<()> { let JsExportNamedShorthandSpecifierFields { type_token, name } = node.as_fields(); if let Some(type_token) = type_token { diff --git a/crates/rome_js_formatter/src/js/module/export_named_specifier.rs b/crates/rome_js_formatter/src/js/module/export_named_specifier.rs index f85ffc15049..bec8a755043 100644 --- a/crates/rome_js_formatter/src/js/module/export_named_specifier.rs +++ b/crates/rome_js_formatter/src/js/module/export_named_specifier.rs @@ -6,7 +6,7 @@ use rome_js_syntax::JsExportNamedSpecifier; use rome_js_syntax::JsExportNamedSpecifierFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsExportNamedSpecifier, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsExportNamedSpecifier, f: &mut JsFormatter) -> FormatResult<()> { let JsExportNamedSpecifierFields { type_token, local_name, diff --git a/crates/rome_js_formatter/src/js/module/import.rs b/crates/rome_js_formatter/src/js/module/import.rs index 3233a998f7e..2b8bfd3a35f 100644 --- a/crates/rome_js_formatter/src/js/module/import.rs +++ b/crates/rome_js_formatter/src/js/module/import.rs @@ -7,7 +7,7 @@ use rome_js_syntax::JsImport; use rome_js_syntax::JsImportFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsImport, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsImport, f: &mut JsFormatter) -> FormatResult<()> { let JsImportFields { import_token, import_clause, diff --git a/crates/rome_js_formatter/src/js/module/import_assertion.rs b/crates/rome_js_formatter/src/js/module/import_assertion.rs index 9e2d3d56068..fef10d16da7 100644 --- a/crates/rome_js_formatter/src/js/module/import_assertion.rs +++ b/crates/rome_js_formatter/src/js/module/import_assertion.rs @@ -5,7 +5,7 @@ use rome_js_syntax::JsImportAssertion; use rome_js_syntax::JsImportAssertionFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsImportAssertion, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsImportAssertion, f: &mut JsFormatter) -> FormatResult<()> { let JsImportAssertionFields { assert_token, l_curly_token, diff --git a/crates/rome_js_formatter/src/js/module/import_assertion_entry.rs b/crates/rome_js_formatter/src/js/module/import_assertion_entry.rs index a5394595b05..ab1ac0019b7 100644 --- a/crates/rome_js_formatter/src/js/module/import_assertion_entry.rs +++ b/crates/rome_js_formatter/src/js/module/import_assertion_entry.rs @@ -1,13 +1,13 @@ use crate::prelude::*; use rome_formatter::write; -use crate::utils::FormatLiteralStringToken; +use crate::utils::{FormatLiteralStringToken, StringLiteralParentKind}; use crate::FormatNodeFields; use rome_js_syntax::JsImportAssertionEntryFields; use rome_js_syntax::{JsImportAssertionEntry, JsSyntaxKind}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsImportAssertionEntry, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsImportAssertionEntry, f: &mut JsFormatter) -> FormatResult<()> { let JsImportAssertionEntryFields { key, colon_token, @@ -18,7 +18,13 @@ impl FormatNodeFields for FormatNodeRule { - write!(f, [FormatLiteralStringToken::from_string(&key)])?; + write!( + f, + [FormatLiteralStringToken::new( + &key, + StringLiteralParentKind::Expression + )] + )?; } _ => { write![f, [key.format()]]?; @@ -30,7 +36,7 @@ impl FormatNodeFields for FormatNodeRule for FormatNodeRule { - fn format_fields(node: &JsImportBareClause, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsImportBareClause, f: &mut JsFormatter) -> FormatResult<()> { let JsImportBareClauseFields { source, assertion } = node.as_fields(); write!(f, [source.format()])?; diff --git a/crates/rome_js_formatter/src/js/module/import_default_clause.rs b/crates/rome_js_formatter/src/js/module/import_default_clause.rs index a7468884361..10a11a953d0 100644 --- a/crates/rome_js_formatter/src/js/module/import_default_clause.rs +++ b/crates/rome_js_formatter/src/js/module/import_default_clause.rs @@ -5,7 +5,7 @@ use rome_js_syntax::JsImportDefaultClause; use rome_js_syntax::JsImportDefaultClauseFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsImportDefaultClause, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsImportDefaultClause, f: &mut JsFormatter) -> FormatResult<()> { let JsImportDefaultClauseFields { type_token, local_name, diff --git a/crates/rome_js_formatter/src/js/module/import_meta.rs b/crates/rome_js_formatter/src/js/module/import_meta.rs index 5a6d79c376b..2adf9ac52e8 100644 --- a/crates/rome_js_formatter/src/js/module/import_meta.rs +++ b/crates/rome_js_formatter/src/js/module/import_meta.rs @@ -5,7 +5,7 @@ use rome_js_syntax::ImportMeta; use rome_js_syntax::ImportMetaFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &ImportMeta, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &ImportMeta, f: &mut JsFormatter) -> FormatResult<()> { let ImportMetaFields { import_token, dot_token, diff --git a/crates/rome_js_formatter/src/js/module/import_named_clause.rs b/crates/rome_js_formatter/src/js/module/import_named_clause.rs index e66b69fc7cc..695658c1434 100644 --- a/crates/rome_js_formatter/src/js/module/import_named_clause.rs +++ b/crates/rome_js_formatter/src/js/module/import_named_clause.rs @@ -5,7 +5,7 @@ use rome_js_syntax::JsImportNamedClause; use rome_js_syntax::JsImportNamedClauseFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsImportNamedClause, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsImportNamedClause, f: &mut JsFormatter) -> FormatResult<()> { let JsImportNamedClauseFields { type_token, default_specifier, diff --git a/crates/rome_js_formatter/src/js/module/import_namespace_clause.rs b/crates/rome_js_formatter/src/js/module/import_namespace_clause.rs index c6702e20f03..dc65173a36e 100644 --- a/crates/rome_js_formatter/src/js/module/import_namespace_clause.rs +++ b/crates/rome_js_formatter/src/js/module/import_namespace_clause.rs @@ -5,7 +5,7 @@ use rome_js_syntax::JsImportNamespaceClause; use rome_js_syntax::JsImportNamespaceClauseFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsImportNamespaceClause, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsImportNamespaceClause, f: &mut JsFormatter) -> FormatResult<()> { let JsImportNamespaceClauseFields { type_token, star_token, diff --git a/crates/rome_js_formatter/src/js/module/literal_export_name.rs b/crates/rome_js_formatter/src/js/module/literal_export_name.rs index a73454ce255..478371fe446 100644 --- a/crates/rome_js_formatter/src/js/module/literal_export_name.rs +++ b/crates/rome_js_formatter/src/js/module/literal_export_name.rs @@ -1,14 +1,20 @@ use crate::prelude::*; -use crate::utils::FormatLiteralStringToken; +use crate::utils::{FormatLiteralStringToken, StringLiteralParentKind}; use crate::FormatNodeFields; -use rome_formatter::write; use rome_js_syntax::JsLiteralExportName; use rome_js_syntax::JsLiteralExportNameFields; +use rome_js_syntax::JsSyntaxKind::JS_STRING_LITERAL; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsLiteralExportName, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsLiteralExportName, f: &mut JsFormatter) -> FormatResult<()> { let JsLiteralExportNameFields { value } = node.as_fields(); - write!(f, [FormatLiteralStringToken::from_string(&value?)]) + let value = value?; + + if value.kind() == JS_STRING_LITERAL { + FormatLiteralStringToken::new(&value, StringLiteralParentKind::Expression).fmt(f) + } else { + value.format().fmt(f) + } } } diff --git a/crates/rome_js_formatter/src/js/module/module_source.rs b/crates/rome_js_formatter/src/js/module/module_source.rs index e642bacce37..025670dc0b5 100644 --- a/crates/rome_js_formatter/src/js/module/module_source.rs +++ b/crates/rome_js_formatter/src/js/module/module_source.rs @@ -1,14 +1,20 @@ use crate::prelude::*; -use crate::utils::FormatLiteralStringToken; +use crate::utils::{FormatLiteralStringToken, StringLiteralParentKind}; use crate::FormatNodeFields; use rome_formatter::write; use rome_js_syntax::JsModuleSource; use rome_js_syntax::JsModuleSourceFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsModuleSource, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsModuleSource, f: &mut JsFormatter) -> FormatResult<()> { let JsModuleSourceFields { value_token } = node.as_fields(); - write!(f, [FormatLiteralStringToken::from_string(&value_token?)]) + write!( + f, + [FormatLiteralStringToken::new( + &value_token?, + StringLiteralParentKind::Expression + )] + ) } } diff --git a/crates/rome_js_formatter/src/js/module/named_import_specifier.rs b/crates/rome_js_formatter/src/js/module/named_import_specifier.rs index 1a928bf42f5..c4be16c2730 100644 --- a/crates/rome_js_formatter/src/js/module/named_import_specifier.rs +++ b/crates/rome_js_formatter/src/js/module/named_import_specifier.rs @@ -5,7 +5,7 @@ use rome_js_syntax::JsNamedImportSpecifier; use rome_js_syntax::JsNamedImportSpecifierFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsNamedImportSpecifier, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsNamedImportSpecifier, f: &mut JsFormatter) -> FormatResult<()> { let JsNamedImportSpecifierFields { type_token, name, diff --git a/crates/rome_js_formatter/src/js/module/named_import_specifiers.rs b/crates/rome_js_formatter/src/js/module/named_import_specifiers.rs index e25c694189e..211181df088 100644 --- a/crates/rome_js_formatter/src/js/module/named_import_specifiers.rs +++ b/crates/rome_js_formatter/src/js/module/named_import_specifiers.rs @@ -5,7 +5,7 @@ use rome_js_syntax::JsNamedImportSpecifiers; use rome_js_syntax::JsNamedImportSpecifiersFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsNamedImportSpecifiers, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsNamedImportSpecifiers, f: &mut JsFormatter) -> FormatResult<()> { let JsNamedImportSpecifiersFields { l_curly_token, specifiers, diff --git a/crates/rome_js_formatter/src/js/module/namespace_import_specifier.rs b/crates/rome_js_formatter/src/js/module/namespace_import_specifier.rs index 061beef7de5..d14cb7f01bd 100644 --- a/crates/rome_js_formatter/src/js/module/namespace_import_specifier.rs +++ b/crates/rome_js_formatter/src/js/module/namespace_import_specifier.rs @@ -5,7 +5,7 @@ use rome_js_syntax::JsNamespaceImportSpecifier; use rome_js_syntax::JsNamespaceImportSpecifierFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsNamespaceImportSpecifier, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsNamespaceImportSpecifier, f: &mut JsFormatter) -> FormatResult<()> { let JsNamespaceImportSpecifierFields { star_token, as_token, diff --git a/crates/rome_js_formatter/src/js/module/shorthand_named_import_specifier.rs b/crates/rome_js_formatter/src/js/module/shorthand_named_import_specifier.rs index e17122f0625..35e027a6396 100644 --- a/crates/rome_js_formatter/src/js/module/shorthand_named_import_specifier.rs +++ b/crates/rome_js_formatter/src/js/module/shorthand_named_import_specifier.rs @@ -7,10 +7,7 @@ use rome_js_syntax::JsShorthandNamedImportSpecifierFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields( - node: &JsShorthandNamedImportSpecifier, - f: &mut JsFormatter, - ) -> FormatResult<()> { + fn fmt_fields(node: &JsShorthandNamedImportSpecifier, f: &mut JsFormatter) -> FormatResult<()> { let JsShorthandNamedImportSpecifierFields { type_token, local_name, diff --git a/crates/rome_js_formatter/src/js/objects/computed_member_name.rs b/crates/rome_js_formatter/src/js/objects/computed_member_name.rs index ed1c381b24e..4d415936473 100644 --- a/crates/rome_js_formatter/src/js/objects/computed_member_name.rs +++ b/crates/rome_js_formatter/src/js/objects/computed_member_name.rs @@ -5,7 +5,7 @@ use rome_js_syntax::JsComputedMemberName; use rome_js_syntax::JsComputedMemberNameFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsComputedMemberName, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsComputedMemberName, f: &mut JsFormatter) -> FormatResult<()> { let JsComputedMemberNameFields { l_brack_token, expression, diff --git a/crates/rome_js_formatter/src/js/objects/getter_object_member.rs b/crates/rome_js_formatter/src/js/objects/getter_object_member.rs index eaff490340a..aecfc17e392 100644 --- a/crates/rome_js_formatter/src/js/objects/getter_object_member.rs +++ b/crates/rome_js_formatter/src/js/objects/getter_object_member.rs @@ -5,7 +5,7 @@ use rome_js_syntax::JsGetterObjectMember; use rome_js_syntax::JsGetterObjectMemberFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsGetterObjectMember, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsGetterObjectMember, f: &mut JsFormatter) -> FormatResult<()> { let JsGetterObjectMemberFields { get_token, name, diff --git a/crates/rome_js_formatter/src/js/objects/literal_member_name.rs b/crates/rome_js_formatter/src/js/objects/literal_member_name.rs index df539e064d3..479da4c7e59 100644 --- a/crates/rome_js_formatter/src/js/objects/literal_member_name.rs +++ b/crates/rome_js_formatter/src/js/objects/literal_member_name.rs @@ -1,19 +1,25 @@ use crate::prelude::*; -use crate::utils::FormatLiteralStringToken; +use crate::utils::{FormatLiteralStringToken, StringLiteralParentKind}; use crate::FormatNodeFields; use rome_formatter::write; use rome_js_syntax::JsLiteralMemberNameFields; use rome_js_syntax::{JsLiteralMemberName, JsSyntaxKind}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsLiteralMemberName, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsLiteralMemberName, f: &mut JsFormatter) -> FormatResult<()> { let JsLiteralMemberNameFields { value } = node.as_fields(); let value = value?; match value.kind() { JsSyntaxKind::JS_STRING_LITERAL => { - write!(f, [FormatLiteralStringToken::from_string(&value)]) + write![ + f, + [FormatLiteralStringToken::new( + &value, + StringLiteralParentKind::Expression + )] + ] } _ => write![f, [value.format()]], } diff --git a/crates/rome_js_formatter/src/js/objects/method_object_member.rs b/crates/rome_js_formatter/src/js/objects/method_object_member.rs index d1115207af9..8c2b08b8a8e 100644 --- a/crates/rome_js_formatter/src/js/objects/method_object_member.rs +++ b/crates/rome_js_formatter/src/js/objects/method_object_member.rs @@ -6,7 +6,7 @@ use rome_js_syntax::JsMethodObjectMember; use rome_js_syntax::JsMethodObjectMemberFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsMethodObjectMember, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsMethodObjectMember, f: &mut JsFormatter) -> FormatResult<()> { let JsMethodObjectMemberFields { async_token, star_token, diff --git a/crates/rome_js_formatter/src/js/objects/private_class_member_name.rs b/crates/rome_js_formatter/src/js/objects/private_class_member_name.rs index b89ccfc6e67..68c3f1a2f16 100644 --- a/crates/rome_js_formatter/src/js/objects/private_class_member_name.rs +++ b/crates/rome_js_formatter/src/js/objects/private_class_member_name.rs @@ -5,7 +5,7 @@ use rome_js_syntax::JsPrivateClassMemberName; use rome_js_syntax::JsPrivateClassMemberNameFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsPrivateClassMemberName, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsPrivateClassMemberName, f: &mut JsFormatter) -> FormatResult<()> { let JsPrivateClassMemberNameFields { hash_token, id_token, diff --git a/crates/rome_js_formatter/src/js/objects/property_object_member.rs b/crates/rome_js_formatter/src/js/objects/property_object_member.rs index b80d84bd3c1..16932c8be4c 100644 --- a/crates/rome_js_formatter/src/js/objects/property_object_member.rs +++ b/crates/rome_js_formatter/src/js/objects/property_object_member.rs @@ -1,11 +1,12 @@ use crate::prelude::*; +use crate::utils::FormatMemberName; use crate::FormatNodeFields; use rome_formatter::write; use rome_js_syntax::JsPropertyObjectMember; use rome_js_syntax::JsPropertyObjectMemberFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsPropertyObjectMember, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsPropertyObjectMember, f: &mut JsFormatter) -> FormatResult<()> { let JsPropertyObjectMemberFields { name, colon_token, @@ -15,7 +16,7 @@ impl FormatNodeFields for FormatNodeRule for FormatNodeRule { - fn format_fields(node: &JsSetterObjectMember, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsSetterObjectMember, f: &mut JsFormatter) -> FormatResult<()> { let JsSetterObjectMemberFields { set_token, name, diff --git a/crates/rome_js_formatter/src/js/objects/shorthand_property_object_member.rs b/crates/rome_js_formatter/src/js/objects/shorthand_property_object_member.rs index ee97149a394..116fa4bdc5b 100644 --- a/crates/rome_js_formatter/src/js/objects/shorthand_property_object_member.rs +++ b/crates/rome_js_formatter/src/js/objects/shorthand_property_object_member.rs @@ -7,10 +7,7 @@ use rome_js_syntax::JsShorthandPropertyObjectMemberFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields( - node: &JsShorthandPropertyObjectMember, - f: &mut JsFormatter, - ) -> FormatResult<()> { + fn fmt_fields(node: &JsShorthandPropertyObjectMember, f: &mut JsFormatter) -> FormatResult<()> { let JsShorthandPropertyObjectMemberFields { name } = node.as_fields(); write![f, [name.format()]] diff --git a/crates/rome_js_formatter/src/js/statements/block_statement.rs b/crates/rome_js_formatter/src/js/statements/block_statement.rs index 0d690df67ef..242360f8c90 100644 --- a/crates/rome_js_formatter/src/js/statements/block_statement.rs +++ b/crates/rome_js_formatter/src/js/statements/block_statement.rs @@ -9,7 +9,7 @@ use rome_js_syntax::JsSyntaxKind; use rome_rowan::{AstNode, AstNodeList}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsBlockStatement, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsBlockStatement, f: &mut JsFormatter) -> FormatResult<()> { let JsBlockStatementFields { l_curly_token, statements, diff --git a/crates/rome_js_formatter/src/js/statements/break_statement.rs b/crates/rome_js_formatter/src/js/statements/break_statement.rs index 0d47d9701e4..b4725043603 100644 --- a/crates/rome_js_formatter/src/js/statements/break_statement.rs +++ b/crates/rome_js_formatter/src/js/statements/break_statement.rs @@ -7,7 +7,7 @@ use rome_js_syntax::JsBreakStatement; use rome_js_syntax::JsBreakStatementFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsBreakStatement, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsBreakStatement, f: &mut JsFormatter) -> FormatResult<()> { let JsBreakStatementFields { break_token, label_token, diff --git a/crates/rome_js_formatter/src/js/statements/continue_statement.rs b/crates/rome_js_formatter/src/js/statements/continue_statement.rs index 53be71076f7..edbfa0d1347 100644 --- a/crates/rome_js_formatter/src/js/statements/continue_statement.rs +++ b/crates/rome_js_formatter/src/js/statements/continue_statement.rs @@ -7,7 +7,7 @@ use rome_js_syntax::JsContinueStatement; use rome_js_syntax::JsContinueStatementFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsContinueStatement, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsContinueStatement, f: &mut JsFormatter) -> FormatResult<()> { let JsContinueStatementFields { continue_token, label_token, diff --git a/crates/rome_js_formatter/src/js/statements/debugger_statement.rs b/crates/rome_js_formatter/src/js/statements/debugger_statement.rs index e2fd882f152..366a3e38321 100644 --- a/crates/rome_js_formatter/src/js/statements/debugger_statement.rs +++ b/crates/rome_js_formatter/src/js/statements/debugger_statement.rs @@ -7,7 +7,7 @@ use rome_js_syntax::JsDebuggerStatement; use rome_js_syntax::JsDebuggerStatementFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsDebuggerStatement, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsDebuggerStatement, f: &mut JsFormatter) -> FormatResult<()> { let JsDebuggerStatementFields { debugger_token, semicolon_token, diff --git a/crates/rome_js_formatter/src/js/statements/do_while_statement.rs b/crates/rome_js_formatter/src/js/statements/do_while_statement.rs index 9b898464447..f0467e040d9 100644 --- a/crates/rome_js_formatter/src/js/statements/do_while_statement.rs +++ b/crates/rome_js_formatter/src/js/statements/do_while_statement.rs @@ -5,7 +5,7 @@ use rome_js_syntax::JsDoWhileStatementFields; use rome_js_syntax::{JsAnyStatement, JsDoWhileStatement}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsDoWhileStatement, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsDoWhileStatement, f: &mut JsFormatter) -> FormatResult<()> { let JsDoWhileStatementFields { do_token, body, diff --git a/crates/rome_js_formatter/src/js/statements/empty_statement.rs b/crates/rome_js_formatter/src/js/statements/empty_statement.rs index 8a9ad0e17f8..406da324acc 100644 --- a/crates/rome_js_formatter/src/js/statements/empty_statement.rs +++ b/crates/rome_js_formatter/src/js/statements/empty_statement.rs @@ -6,7 +6,7 @@ use rome_js_syntax::{JsEmptyStatement, JsEmptyStatementFields, JsSyntaxKind}; use rome_rowan::AstNode; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsEmptyStatement, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsEmptyStatement, f: &mut JsFormatter) -> FormatResult<()> { let JsEmptyStatementFields { semicolon_token } = node.as_fields(); let parent_kind = node.syntax().parent().map(|p| p.kind()); diff --git a/crates/rome_js_formatter/src/js/statements/expression_statement.rs b/crates/rome_js_formatter/src/js/statements/expression_statement.rs index 71bf8468e2b..1de248cd68a 100644 --- a/crates/rome_js_formatter/src/js/statements/expression_statement.rs +++ b/crates/rome_js_formatter/src/js/statements/expression_statement.rs @@ -7,7 +7,7 @@ use rome_js_syntax::JsExpressionStatement; use rome_js_syntax::JsExpressionStatementFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsExpressionStatement, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsExpressionStatement, f: &mut JsFormatter) -> FormatResult<()> { let JsExpressionStatementFields { expression, semicolon_token, diff --git a/crates/rome_js_formatter/src/js/statements/for_in_statement.rs b/crates/rome_js_formatter/src/js/statements/for_in_statement.rs index df2e9e52763..9cdc777f669 100644 --- a/crates/rome_js_formatter/src/js/statements/for_in_statement.rs +++ b/crates/rome_js_formatter/src/js/statements/for_in_statement.rs @@ -6,7 +6,7 @@ use rome_js_syntax::JsForInStatement; use rome_js_syntax::JsForInStatementFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsForInStatement, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsForInStatement, f: &mut JsFormatter) -> FormatResult<()> { let JsForInStatementFields { for_token, l_paren_token, @@ -24,11 +24,11 @@ impl FormatNodeFields for FormatNodeRule { write!( f, - [group_elements(format_args!( + [group_elements(&format_args!( for_token, space_token(), l_paren_token.format(), - group_elements(initializer), + group_elements(&initializer), space_token(), in_token, space_token(), diff --git a/crates/rome_js_formatter/src/js/statements/for_of_statement.rs b/crates/rome_js_formatter/src/js/statements/for_of_statement.rs index db37935a31b..f91811d6bc5 100644 --- a/crates/rome_js_formatter/src/js/statements/for_of_statement.rs +++ b/crates/rome_js_formatter/src/js/statements/for_of_statement.rs @@ -7,7 +7,7 @@ use crate::FormatNodeFields; use rome_js_syntax::JsForOfStatementFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsForOfStatement, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsForOfStatement, f: &mut JsFormatter) -> FormatResult<()> { let JsForOfStatementFields { for_token, await_token, @@ -21,14 +21,14 @@ impl FormatNodeFields for FormatNodeRule { write!( f, - [group_elements(format_args![ + [group_elements(&format_args![ for_token.format(), space_token(), await_token .format() .with_or_empty(|token, f| write![f, [token, space_token()]]), l_paren_token.format(), - group_elements(initializer.format()), + group_elements(&initializer.format()), space_token(), of_token.format(), space_token(), diff --git a/crates/rome_js_formatter/src/js/statements/for_statement.rs b/crates/rome_js_formatter/src/js/statements/for_statement.rs index fe317889049..979dbc26498 100644 --- a/crates/rome_js_formatter/src/js/statements/for_statement.rs +++ b/crates/rome_js_formatter/src/js/statements/for_statement.rs @@ -7,7 +7,7 @@ use rome_js_syntax::JsForStatement; use rome_js_syntax::JsForStatementFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsForStatement, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsForStatement, f: &mut JsFormatter) -> FormatResult<()> { let JsForStatementFields { for_token, l_paren_token, @@ -61,6 +61,6 @@ impl FormatNodeFields for FormatNodeRule { } }); - write!(f, [group_elements(content)]) + write!(f, [group_elements(&content)]) } } diff --git a/crates/rome_js_formatter/src/js/statements/if_statement.rs b/crates/rome_js_formatter/src/js/statements/if_statement.rs index 497b7be834e..b9aa9f6c44c 100644 --- a/crates/rome_js_formatter/src/js/statements/if_statement.rs +++ b/crates/rome_js_formatter/src/js/statements/if_statement.rs @@ -7,8 +7,8 @@ use rome_js_syntax::{JsAnyStatement, JsElseClauseFields, JsIfStatement}; use rome_js_syntax::{JsElseClause, JsIfStatementFields}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsIfStatement, f: &mut JsFormatter) -> FormatResult<()> { - let mut else_clause = format_if_element(f, None, node)?; + fn fmt_fields(node: &JsIfStatement, f: &mut JsFormatter) -> FormatResult<()> { + let mut else_clause = write_if_element(f, None, node)?; while let Some(clause) = else_clause.take() { let JsElseClauseFields { @@ -18,13 +18,13 @@ impl FormatNodeFields for FormatNodeRule { match alternate? { JsAnyStatement::JsIfStatement(stmt) => { - let alternate = format_if_element(f, Some(else_token?), &stmt)?; + let alternate = write_if_element(f, Some(else_token?), &stmt)?; else_clause = alternate; } alternate => { write![f, [space_token(), else_token.format()]]?; - write_consequent_as_block(f, alternate)?; + write_consequent_block(f, alternate)?; } } } @@ -34,7 +34,7 @@ impl FormatNodeFields for FormatNodeRule { } /// Format a single `else? if(test) consequent` element, returning the next else clause -fn format_if_element( +fn write_if_element( f: &mut JsFormatter, else_token: Option, stmt: &JsIfStatement, @@ -57,17 +57,17 @@ fn format_if_element( [ if_token.format(), space_token(), - format_delimited(&l_paren_token?, &test.format(), &r_paren_token?,).soft_block_indent(), + format_delimited(&l_paren_token?, &test.format(), &r_paren_token?).soft_block_indent(), ] ]?; - write_consequent_as_block(f, consequent?)?; + write_consequent_block(f, consequent?)?; Ok(else_clause) } /// Wraps the statement into a block if its not already a JsBlockStatement -fn write_consequent_as_block(f: &mut JsFormatter, stmt: JsAnyStatement) -> FormatResult<()> { +fn write_consequent_block(f: &mut JsFormatter, stmt: JsAnyStatement) -> FormatResult<()> { if matches!(stmt, JsAnyStatement::JsBlockStatement(_)) { return write![f, [space_token(), stmt.format()]]; } @@ -83,7 +83,7 @@ fn write_consequent_as_block(f: &mut JsFormatter, stmt: JsAnyStatement) -> Forma [ space_token(), token("{"), - block_indent(stmt.format()), + block_indent(&stmt.format()), token("}"), ] ] diff --git a/crates/rome_js_formatter/src/js/statements/labeled_statement.rs b/crates/rome_js_formatter/src/js/statements/labeled_statement.rs index 68e36a55cae..4c830deb3ce 100644 --- a/crates/rome_js_formatter/src/js/statements/labeled_statement.rs +++ b/crates/rome_js_formatter/src/js/statements/labeled_statement.rs @@ -6,7 +6,7 @@ use rome_js_syntax::JsLabeledStatementFields; use rome_js_syntax::{JsAnyStatement, JsLabeledStatement}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsLabeledStatement, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsLabeledStatement, f: &mut JsFormatter) -> FormatResult<()> { let JsLabeledStatementFields { label_token, colon_token, diff --git a/crates/rome_js_formatter/src/js/statements/return_statement.rs b/crates/rome_js_formatter/src/js/statements/return_statement.rs index 0b6b817b8e8..8cb88e17fbe 100644 --- a/crates/rome_js_formatter/src/js/statements/return_statement.rs +++ b/crates/rome_js_formatter/src/js/statements/return_statement.rs @@ -5,7 +5,7 @@ use rome_formatter::{format_args, write}; use rome_js_syntax::{JsAnyExpression, JsReturnStatement, JsReturnStatementFields}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsReturnStatement, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsReturnStatement, f: &mut JsFormatter) -> FormatResult<()> { let JsReturnStatementFields { return_token, argument, @@ -24,9 +24,9 @@ impl FormatNodeFields for FormatNodeRule { if let JsAnyExpression::JsSequenceExpression(_expression) = argument { write![ f, - [group_elements(format_args![ + [group_elements(&format_args![ token("("), - soft_block_indent(argument.format()), + soft_block_indent(&argument.format()), token(")") ])] ]?; diff --git a/crates/rome_js_formatter/src/js/statements/switch_statement.rs b/crates/rome_js_formatter/src/js/statements/switch_statement.rs index c046b8cddcb..a7d7ea06dda 100644 --- a/crates/rome_js_formatter/src/js/statements/switch_statement.rs +++ b/crates/rome_js_formatter/src/js/statements/switch_statement.rs @@ -5,7 +5,7 @@ use rome_js_syntax::{JsSwitchStatement, JsSwitchStatementFields}; use rome_rowan::{AstNode, AstNodeList}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsSwitchStatement, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsSwitchStatement, f: &mut JsFormatter) -> FormatResult<()> { let JsSwitchStatementFields { switch_token, l_paren_token, @@ -16,13 +16,13 @@ impl FormatNodeFields for FormatNodeRule { r_curly_token, } = node.as_fields(); - let format_cases = format_once(|f| { + let format_cases = format_with(|f| { if cases.is_empty() { write!(f, [hard_line_break()])?; } else { let mut join = f.join_nodes_with_hardline(); - for case in cases { + for case in &cases { join.entry(case.syntax(), &case.format()); } diff --git a/crates/rome_js_formatter/src/js/statements/throw_statement.rs b/crates/rome_js_formatter/src/js/statements/throw_statement.rs index e782393699a..cb061fcc4e8 100644 --- a/crates/rome_js_formatter/src/js/statements/throw_statement.rs +++ b/crates/rome_js_formatter/src/js/statements/throw_statement.rs @@ -7,7 +7,7 @@ use rome_js_syntax::JsThrowStatement; use rome_js_syntax::JsThrowStatementFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsThrowStatement, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsThrowStatement, f: &mut JsFormatter) -> FormatResult<()> { let JsThrowStatementFields { throw_token, argument, diff --git a/crates/rome_js_formatter/src/js/statements/try_finally_statement.rs b/crates/rome_js_formatter/src/js/statements/try_finally_statement.rs index abc374477c5..4f4f67945d7 100644 --- a/crates/rome_js_formatter/src/js/statements/try_finally_statement.rs +++ b/crates/rome_js_formatter/src/js/statements/try_finally_statement.rs @@ -6,7 +6,7 @@ use rome_js_syntax::JsTryFinallyStatement; use rome_js_syntax::JsTryFinallyStatementFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsTryFinallyStatement, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsTryFinallyStatement, f: &mut JsFormatter) -> FormatResult<()> { let JsTryFinallyStatementFields { try_token, body, diff --git a/crates/rome_js_formatter/src/js/statements/try_statement.rs b/crates/rome_js_formatter/src/js/statements/try_statement.rs index 85dd050c46e..31a95dcfe78 100644 --- a/crates/rome_js_formatter/src/js/statements/try_statement.rs +++ b/crates/rome_js_formatter/src/js/statements/try_statement.rs @@ -5,7 +5,7 @@ use rome_js_syntax::JsTryStatement; use rome_js_syntax::JsTryStatementFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsTryStatement, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsTryStatement, f: &mut JsFormatter) -> FormatResult<()> { let JsTryStatementFields { try_token, body, diff --git a/crates/rome_js_formatter/src/js/statements/variable_statement.rs b/crates/rome_js_formatter/src/js/statements/variable_statement.rs index 32e32302587..18988678b29 100644 --- a/crates/rome_js_formatter/src/js/statements/variable_statement.rs +++ b/crates/rome_js_formatter/src/js/statements/variable_statement.rs @@ -7,7 +7,7 @@ use rome_js_syntax::JsVariableStatement; use rome_js_syntax::JsVariableStatementFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsVariableStatement, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsVariableStatement, f: &mut JsFormatter) -> FormatResult<()> { let JsVariableStatementFields { declaration, semicolon_token, diff --git a/crates/rome_js_formatter/src/js/statements/while_statement.rs b/crates/rome_js_formatter/src/js/statements/while_statement.rs index 4a64c8d9607..96ef7809189 100644 --- a/crates/rome_js_formatter/src/js/statements/while_statement.rs +++ b/crates/rome_js_formatter/src/js/statements/while_statement.rs @@ -7,7 +7,7 @@ use rome_js_syntax::JsWhileStatement; use rome_js_syntax::JsWhileStatementFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsWhileStatement, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsWhileStatement, f: &mut JsFormatter) -> FormatResult<()> { let JsWhileStatementFields { while_token, l_paren_token, diff --git a/crates/rome_js_formatter/src/js/statements/with_statement.rs b/crates/rome_js_formatter/src/js/statements/with_statement.rs index 01e44c6d984..3b83fa28797 100644 --- a/crates/rome_js_formatter/src/js/statements/with_statement.rs +++ b/crates/rome_js_formatter/src/js/statements/with_statement.rs @@ -7,7 +7,7 @@ use rome_js_syntax::JsWithStatement; use rome_js_syntax::JsWithStatementFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsWithStatement, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsWithStatement, f: &mut JsFormatter) -> FormatResult<()> { let JsWithStatementFields { with_token, l_paren_token, diff --git a/crates/rome_js_formatter/src/js/unknown/unknown.rs b/crates/rome_js_formatter/src/js/unknown/unknown.rs index 3127b897ca1..ea78ccd76be 100644 --- a/crates/rome_js_formatter/src/js/unknown/unknown.rs +++ b/crates/rome_js_formatter/src/js/unknown/unknown.rs @@ -4,7 +4,7 @@ use rome_js_syntax::JsUnknown; use rome_rowan::AstNode; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsUnknown, formatter: &mut JsFormatter) -> FormatResult<()> { - format_unknown_node(node.syntax()).format(formatter) + fn fmt_fields(node: &JsUnknown, formatter: &mut JsFormatter) -> FormatResult<()> { + format_unknown_node(node.syntax()).fmt(formatter) } } diff --git a/crates/rome_js_formatter/src/js/unknown/unknown_assignment.rs b/crates/rome_js_formatter/src/js/unknown/unknown_assignment.rs index e512c49a701..f9fa2e8eb6c 100644 --- a/crates/rome_js_formatter/src/js/unknown/unknown_assignment.rs +++ b/crates/rome_js_formatter/src/js/unknown/unknown_assignment.rs @@ -4,7 +4,7 @@ use rome_js_syntax::JsUnknownAssignment; use rome_rowan::AstNode; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsUnknownAssignment, formatter: &mut JsFormatter) -> FormatResult<()> { - format_unknown_node(node.syntax()).format(formatter) + fn fmt_fields(node: &JsUnknownAssignment, formatter: &mut JsFormatter) -> FormatResult<()> { + format_unknown_node(node.syntax()).fmt(formatter) } } diff --git a/crates/rome_js_formatter/src/js/unknown/unknown_binding.rs b/crates/rome_js_formatter/src/js/unknown/unknown_binding.rs index d931bf84da4..f56b3cdd145 100644 --- a/crates/rome_js_formatter/src/js/unknown/unknown_binding.rs +++ b/crates/rome_js_formatter/src/js/unknown/unknown_binding.rs @@ -5,7 +5,7 @@ use rome_js_syntax::JsUnknownBinding; use rome_rowan::AstNode; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsUnknownBinding, formatter: &mut JsFormatter) -> FormatResult<()> { - format_unknown_node(node.syntax()).format(formatter) + fn fmt_fields(node: &JsUnknownBinding, formatter: &mut JsFormatter) -> FormatResult<()> { + format_unknown_node(node.syntax()).fmt(formatter) } } diff --git a/crates/rome_js_formatter/src/js/unknown/unknown_expression.rs b/crates/rome_js_formatter/src/js/unknown/unknown_expression.rs index 86d325fc28d..ba7e21aa20a 100644 --- a/crates/rome_js_formatter/src/js/unknown/unknown_expression.rs +++ b/crates/rome_js_formatter/src/js/unknown/unknown_expression.rs @@ -5,7 +5,7 @@ use rome_js_syntax::JsUnknownExpression; use rome_rowan::AstNode; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsUnknownExpression, formatter: &mut JsFormatter) -> FormatResult<()> { - format_unknown_node(node.syntax()).format(formatter) + fn fmt_fields(node: &JsUnknownExpression, formatter: &mut JsFormatter) -> FormatResult<()> { + format_unknown_node(node.syntax()).fmt(formatter) } } diff --git a/crates/rome_js_formatter/src/js/unknown/unknown_import_assertion_entry.rs b/crates/rome_js_formatter/src/js/unknown/unknown_import_assertion_entry.rs index 593297a4c3f..e99c7d7c275 100644 --- a/crates/rome_js_formatter/src/js/unknown/unknown_import_assertion_entry.rs +++ b/crates/rome_js_formatter/src/js/unknown/unknown_import_assertion_entry.rs @@ -7,10 +7,10 @@ use rome_rowan::AstNode; impl FormatNodeFields for FormatNodeRule { - fn format_fields( + fn fmt_fields( node: &JsUnknownImportAssertionEntry, formatter: &mut JsFormatter, ) -> FormatResult<()> { - format_unknown_node(node.syntax()).format(formatter) + format_unknown_node(node.syntax()).fmt(formatter) } } diff --git a/crates/rome_js_formatter/src/js/unknown/unknown_member.rs b/crates/rome_js_formatter/src/js/unknown/unknown_member.rs index 6a782c4e62e..c2fe342bd73 100644 --- a/crates/rome_js_formatter/src/js/unknown/unknown_member.rs +++ b/crates/rome_js_formatter/src/js/unknown/unknown_member.rs @@ -5,7 +5,7 @@ use rome_js_syntax::JsUnknownMember; use rome_rowan::AstNode; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsUnknownMember, formatter: &mut JsFormatter) -> FormatResult<()> { - format_unknown_node(node.syntax()).format(formatter) + fn fmt_fields(node: &JsUnknownMember, formatter: &mut JsFormatter) -> FormatResult<()> { + format_unknown_node(node.syntax()).fmt(formatter) } } diff --git a/crates/rome_js_formatter/src/js/unknown/unknown_named_import_specifier.rs b/crates/rome_js_formatter/src/js/unknown/unknown_named_import_specifier.rs index 2fc0e668897..476cff2c0bd 100644 --- a/crates/rome_js_formatter/src/js/unknown/unknown_named_import_specifier.rs +++ b/crates/rome_js_formatter/src/js/unknown/unknown_named_import_specifier.rs @@ -7,10 +7,10 @@ use rome_rowan::AstNode; impl FormatNodeFields for FormatNodeRule { - fn format_fields( + fn fmt_fields( node: &JsUnknownNamedImportSpecifier, formatter: &mut JsFormatter, ) -> FormatResult<()> { - format_unknown_node(node.syntax()).format(formatter) + format_unknown_node(node.syntax()).fmt(formatter) } } diff --git a/crates/rome_js_formatter/src/js/unknown/unknown_parameter.rs b/crates/rome_js_formatter/src/js/unknown/unknown_parameter.rs index 478a7ddb35b..0ab6e6af5e2 100644 --- a/crates/rome_js_formatter/src/js/unknown/unknown_parameter.rs +++ b/crates/rome_js_formatter/src/js/unknown/unknown_parameter.rs @@ -5,7 +5,7 @@ use rome_js_syntax::JsUnknownParameter; use rome_rowan::AstNode; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsUnknownParameter, formatter: &mut JsFormatter) -> FormatResult<()> { - format_unknown_node(node.syntax()).format(formatter) + fn fmt_fields(node: &JsUnknownParameter, formatter: &mut JsFormatter) -> FormatResult<()> { + format_unknown_node(node.syntax()).fmt(formatter) } } diff --git a/crates/rome_js_formatter/src/js/unknown/unknown_statement.rs b/crates/rome_js_formatter/src/js/unknown/unknown_statement.rs index 08dbdfb27d3..77596cf90c8 100644 --- a/crates/rome_js_formatter/src/js/unknown/unknown_statement.rs +++ b/crates/rome_js_formatter/src/js/unknown/unknown_statement.rs @@ -5,7 +5,7 @@ use rome_js_syntax::JsUnknownStatement; use rome_rowan::AstNode; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsUnknownStatement, formatter: &mut JsFormatter) -> FormatResult<()> { - format_unknown_node(node.syntax()).format(formatter) + fn fmt_fields(node: &JsUnknownStatement, formatter: &mut JsFormatter) -> FormatResult<()> { + format_unknown_node(node.syntax()).fmt(formatter) } } diff --git a/crates/rome_js_formatter/src/jsx/any/attribute.rs b/crates/rome_js_formatter/src/jsx/any/attribute.rs index 0b8ffddda85..1bc2726a6a0 100644 --- a/crates/rome_js_formatter/src/jsx/any/attribute.rs +++ b/crates/rome_js_formatter/src/jsx/any/attribute.rs @@ -5,10 +5,10 @@ use crate::prelude::*; use rome_js_syntax::JsxAnyAttribute; impl FormatRule for FormatJsxAnyAttribute { type Context = JsFormatContext; - fn format(node: &JsxAnyAttribute, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &JsxAnyAttribute, f: &mut JsFormatter) -> FormatResult<()> { match node { - JsxAnyAttribute::JsxAttribute(node) => node.format().format(f), - JsxAnyAttribute::JsxSpreadAttribute(node) => node.format().format(f), + JsxAnyAttribute::JsxAttribute(node) => node.format().fmt(f), + JsxAnyAttribute::JsxSpreadAttribute(node) => node.format().fmt(f), } } } diff --git a/crates/rome_js_formatter/src/jsx/any/attribute_name.rs b/crates/rome_js_formatter/src/jsx/any/attribute_name.rs index 09bd8c452a7..13606a65df2 100644 --- a/crates/rome_js_formatter/src/jsx/any/attribute_name.rs +++ b/crates/rome_js_formatter/src/jsx/any/attribute_name.rs @@ -5,10 +5,10 @@ use crate::prelude::*; use rome_js_syntax::JsxAnyAttributeName; impl FormatRule for FormatJsxAnyAttributeName { type Context = JsFormatContext; - fn format(node: &JsxAnyAttributeName, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &JsxAnyAttributeName, f: &mut JsFormatter) -> FormatResult<()> { match node { - JsxAnyAttributeName::JsxName(node) => node.format().format(f), - JsxAnyAttributeName::JsxNamespaceName(node) => node.format().format(f), + JsxAnyAttributeName::JsxName(node) => node.format().fmt(f), + JsxAnyAttributeName::JsxNamespaceName(node) => node.format().fmt(f), } } } diff --git a/crates/rome_js_formatter/src/jsx/any/attribute_value.rs b/crates/rome_js_formatter/src/jsx/any/attribute_value.rs index f7865668e2e..0bede1f2d85 100644 --- a/crates/rome_js_formatter/src/jsx/any/attribute_value.rs +++ b/crates/rome_js_formatter/src/jsx/any/attribute_value.rs @@ -5,11 +5,11 @@ use crate::prelude::*; use rome_js_syntax::JsxAnyAttributeValue; impl FormatRule for FormatJsxAnyAttributeValue { type Context = JsFormatContext; - fn format(node: &JsxAnyAttributeValue, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &JsxAnyAttributeValue, f: &mut JsFormatter) -> FormatResult<()> { match node { - JsxAnyAttributeValue::JsxAnyTag(node) => node.format().format(f), - JsxAnyAttributeValue::JsxString(node) => node.format().format(f), - JsxAnyAttributeValue::JsxExpressionAttributeValue(node) => node.format().format(f), + JsxAnyAttributeValue::JsxAnyTag(node) => node.format().fmt(f), + JsxAnyAttributeValue::JsxString(node) => node.format().fmt(f), + JsxAnyAttributeValue::JsxExpressionAttributeValue(node) => node.format().fmt(f), } } } diff --git a/crates/rome_js_formatter/src/jsx/any/child.rs b/crates/rome_js_formatter/src/jsx/any/child.rs index 145dd2dd625..1be4d22cc56 100644 --- a/crates/rome_js_formatter/src/jsx/any/child.rs +++ b/crates/rome_js_formatter/src/jsx/any/child.rs @@ -5,14 +5,14 @@ use crate::prelude::*; use rome_js_syntax::JsxAnyChild; impl FormatRule for FormatJsxAnyChild { type Context = JsFormatContext; - fn format(node: &JsxAnyChild, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &JsxAnyChild, f: &mut JsFormatter) -> FormatResult<()> { match node { - JsxAnyChild::JsxElement(node) => node.format().format(f), - JsxAnyChild::JsxSelfClosingElement(node) => node.format().format(f), - JsxAnyChild::JsxText(node) => node.format().format(f), - JsxAnyChild::JsxExpressionChild(node) => node.format().format(f), - JsxAnyChild::JsxSpreadChild(node) => node.format().format(f), - JsxAnyChild::JsxFragment(node) => node.format().format(f), + JsxAnyChild::JsxElement(node) => node.format().fmt(f), + JsxAnyChild::JsxSelfClosingElement(node) => node.format().fmt(f), + JsxAnyChild::JsxText(node) => node.format().fmt(f), + JsxAnyChild::JsxExpressionChild(node) => node.format().fmt(f), + JsxAnyChild::JsxSpreadChild(node) => node.format().fmt(f), + JsxAnyChild::JsxFragment(node) => node.format().fmt(f), } } } diff --git a/crates/rome_js_formatter/src/jsx/any/element_name.rs b/crates/rome_js_formatter/src/jsx/any/element_name.rs index 1ec70481b5a..c40674d3121 100644 --- a/crates/rome_js_formatter/src/jsx/any/element_name.rs +++ b/crates/rome_js_formatter/src/jsx/any/element_name.rs @@ -5,12 +5,12 @@ use crate::prelude::*; use rome_js_syntax::JsxAnyElementName; impl FormatRule for FormatJsxAnyElementName { type Context = JsFormatContext; - fn format(node: &JsxAnyElementName, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &JsxAnyElementName, f: &mut JsFormatter) -> FormatResult<()> { match node { - JsxAnyElementName::JsxName(node) => node.format().format(f), - JsxAnyElementName::JsxReferenceIdentifier(node) => node.format().format(f), - JsxAnyElementName::JsxMemberName(node) => node.format().format(f), - JsxAnyElementName::JsxNamespaceName(node) => node.format().format(f), + JsxAnyElementName::JsxName(node) => node.format().fmt(f), + JsxAnyElementName::JsxReferenceIdentifier(node) => node.format().fmt(f), + JsxAnyElementName::JsxMemberName(node) => node.format().fmt(f), + JsxAnyElementName::JsxNamespaceName(node) => node.format().fmt(f), } } } diff --git a/crates/rome_js_formatter/src/jsx/any/name.rs b/crates/rome_js_formatter/src/jsx/any/name.rs index 1c625ba744c..33c310c4fc8 100644 --- a/crates/rome_js_formatter/src/jsx/any/name.rs +++ b/crates/rome_js_formatter/src/jsx/any/name.rs @@ -5,10 +5,10 @@ use crate::prelude::*; use rome_js_syntax::JsxAnyName; impl FormatRule for FormatJsxAnyName { type Context = JsFormatContext; - fn format(node: &JsxAnyName, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &JsxAnyName, f: &mut JsFormatter) -> FormatResult<()> { match node { - JsxAnyName::JsxName(node) => node.format().format(f), - JsxAnyName::JsxNamespaceName(node) => node.format().format(f), + JsxAnyName::JsxName(node) => node.format().fmt(f), + JsxAnyName::JsxNamespaceName(node) => node.format().fmt(f), } } } diff --git a/crates/rome_js_formatter/src/jsx/any/object_name.rs b/crates/rome_js_formatter/src/jsx/any/object_name.rs index a77d9518931..740d219945b 100644 --- a/crates/rome_js_formatter/src/jsx/any/object_name.rs +++ b/crates/rome_js_formatter/src/jsx/any/object_name.rs @@ -5,11 +5,11 @@ use crate::prelude::*; use rome_js_syntax::JsxAnyObjectName; impl FormatRule for FormatJsxAnyObjectName { type Context = JsFormatContext; - fn format(node: &JsxAnyObjectName, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &JsxAnyObjectName, f: &mut JsFormatter) -> FormatResult<()> { match node { - JsxAnyObjectName::JsxReferenceIdentifier(node) => node.format().format(f), - JsxAnyObjectName::JsxMemberName(node) => node.format().format(f), - JsxAnyObjectName::JsxNamespaceName(node) => node.format().format(f), + JsxAnyObjectName::JsxReferenceIdentifier(node) => node.format().fmt(f), + JsxAnyObjectName::JsxMemberName(node) => node.format().fmt(f), + JsxAnyObjectName::JsxNamespaceName(node) => node.format().fmt(f), } } } diff --git a/crates/rome_js_formatter/src/jsx/any/tag.rs b/crates/rome_js_formatter/src/jsx/any/tag.rs index 82ed1507661..1c346ae0a1c 100644 --- a/crates/rome_js_formatter/src/jsx/any/tag.rs +++ b/crates/rome_js_formatter/src/jsx/any/tag.rs @@ -5,11 +5,11 @@ use crate::prelude::*; use rome_js_syntax::JsxAnyTag; impl FormatRule for FormatJsxAnyTag { type Context = JsFormatContext; - fn format(node: &JsxAnyTag, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &JsxAnyTag, f: &mut JsFormatter) -> FormatResult<()> { match node { - JsxAnyTag::JsxElement(node) => node.format().format(f), - JsxAnyTag::JsxSelfClosingElement(node) => node.format().format(f), - JsxAnyTag::JsxFragment(node) => node.format().format(f), + JsxAnyTag::JsxElement(node) => node.format().fmt(f), + JsxAnyTag::JsxSelfClosingElement(node) => node.format().fmt(f), + JsxAnyTag::JsxFragment(node) => node.format().fmt(f), } } } diff --git a/crates/rome_js_formatter/src/jsx/attribute/attribute.rs b/crates/rome_js_formatter/src/jsx/attribute/attribute.rs index df7b7918441..5af0f5a5637 100644 --- a/crates/rome_js_formatter/src/jsx/attribute/attribute.rs +++ b/crates/rome_js_formatter/src/jsx/attribute/attribute.rs @@ -4,7 +4,7 @@ use rome_formatter::write; use rome_js_syntax::{JsxAttribute, JsxAttributeFields}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsxAttribute, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsxAttribute, f: &mut JsFormatter) -> FormatResult<()> { let JsxAttributeFields { name, initializer } = node.as_fields(); write![f, [name.format(), initializer.format()]] diff --git a/crates/rome_js_formatter/src/jsx/attribute/attribute_initializer_clause.rs b/crates/rome_js_formatter/src/jsx/attribute/attribute_initializer_clause.rs index 51581a11a37..08c3240d79e 100644 --- a/crates/rome_js_formatter/src/jsx/attribute/attribute_initializer_clause.rs +++ b/crates/rome_js_formatter/src/jsx/attribute/attribute_initializer_clause.rs @@ -6,10 +6,7 @@ use rome_js_syntax::{JsxAttributeInitializerClause, JsxAttributeInitializerClaus impl FormatNodeFields for FormatNodeRule { - fn format_fields( - node: &JsxAttributeInitializerClause, - f: &mut JsFormatter, - ) -> FormatResult<()> { + fn fmt_fields(node: &JsxAttributeInitializerClause, f: &mut JsFormatter) -> FormatResult<()> { let JsxAttributeInitializerClauseFields { eq_token, value } = node.as_fields(); write![f, [eq_token.format(), value.format()]] diff --git a/crates/rome_js_formatter/src/jsx/attribute/expression_attribute_value.rs b/crates/rome_js_formatter/src/jsx/attribute/expression_attribute_value.rs index 0c5c144e462..d332f18abe8 100644 --- a/crates/rome_js_formatter/src/jsx/attribute/expression_attribute_value.rs +++ b/crates/rome_js_formatter/src/jsx/attribute/expression_attribute_value.rs @@ -6,7 +6,7 @@ use rome_js_syntax::{ }; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsxExpressionAttributeValue, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsxExpressionAttributeValue, f: &mut JsFormatter) -> FormatResult<()> { let JsxExpressionAttributeValueFields { l_curly_token, expression, @@ -15,7 +15,7 @@ impl FormatNodeFields for FormatNodeRule for FormatNodeRule for FormatNodeRule { - fn format_fields(node: &JsxSpreadAttribute, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsxSpreadAttribute, f: &mut JsFormatter) -> FormatResult<()> { let JsxSpreadAttributeFields { l_curly_token, dotdotdot_token, diff --git a/crates/rome_js_formatter/src/jsx/auxiliary/expression_child.rs b/crates/rome_js_formatter/src/jsx/auxiliary/expression_child.rs index f82689e7159..33cbb8a4069 100644 --- a/crates/rome_js_formatter/src/jsx/auxiliary/expression_child.rs +++ b/crates/rome_js_formatter/src/jsx/auxiliary/expression_child.rs @@ -4,7 +4,7 @@ use rome_js_syntax::JsxExpressionChild; use rome_rowan::AstNode; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsxExpressionChild, formatter: &mut JsFormatter) -> FormatResult<()> { - format_verbatim_node(node.syntax()).format(formatter) + fn fmt_fields(node: &JsxExpressionChild, formatter: &mut JsFormatter) -> FormatResult<()> { + format_verbatim_node(node.syntax()).fmt(formatter) } } diff --git a/crates/rome_js_formatter/src/jsx/auxiliary/name.rs b/crates/rome_js_formatter/src/jsx/auxiliary/name.rs index bbbf9b7a936..f135ef7e14a 100644 --- a/crates/rome_js_formatter/src/jsx/auxiliary/name.rs +++ b/crates/rome_js_formatter/src/jsx/auxiliary/name.rs @@ -4,7 +4,7 @@ use rome_formatter::write; use rome_js_syntax::{JsxName, JsxNameFields}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsxName, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsxName, f: &mut JsFormatter) -> FormatResult<()> { let JsxNameFields { value_token } = node.as_fields(); write![f, [value_token.format()]] diff --git a/crates/rome_js_formatter/src/jsx/auxiliary/namespace_name.rs b/crates/rome_js_formatter/src/jsx/auxiliary/namespace_name.rs index 2b90741543d..c3da901ba55 100644 --- a/crates/rome_js_formatter/src/jsx/auxiliary/namespace_name.rs +++ b/crates/rome_js_formatter/src/jsx/auxiliary/namespace_name.rs @@ -4,7 +4,7 @@ use rome_formatter::write; use rome_js_syntax::{JsxNamespaceName, JsxNamespaceNameFields}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsxNamespaceName, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsxNamespaceName, f: &mut JsFormatter) -> FormatResult<()> { let JsxNamespaceNameFields { namespace, colon_token, diff --git a/crates/rome_js_formatter/src/jsx/auxiliary/reference_identifier.rs b/crates/rome_js_formatter/src/jsx/auxiliary/reference_identifier.rs index 66660bc30ba..80a3c483222 100644 --- a/crates/rome_js_formatter/src/jsx/auxiliary/reference_identifier.rs +++ b/crates/rome_js_formatter/src/jsx/auxiliary/reference_identifier.rs @@ -4,7 +4,7 @@ use rome_formatter::write; use rome_js_syntax::JsxReferenceIdentifier; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsxReferenceIdentifier, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsxReferenceIdentifier, f: &mut JsFormatter) -> FormatResult<()> { write![f, [node.value_token().format()]] } } diff --git a/crates/rome_js_formatter/src/jsx/auxiliary/spread_child.rs b/crates/rome_js_formatter/src/jsx/auxiliary/spread_child.rs index f367ac66472..fe3b3508eb9 100644 --- a/crates/rome_js_formatter/src/jsx/auxiliary/spread_child.rs +++ b/crates/rome_js_formatter/src/jsx/auxiliary/spread_child.rs @@ -4,7 +4,7 @@ use rome_js_syntax::JsxSpreadChild; use rome_rowan::AstNode; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsxSpreadChild, formatter: &mut JsFormatter) -> FormatResult<()> { - format_verbatim_node(node.syntax()).format(formatter) + fn fmt_fields(node: &JsxSpreadChild, formatter: &mut JsFormatter) -> FormatResult<()> { + format_verbatim_node(node.syntax()).fmt(formatter) } } diff --git a/crates/rome_js_formatter/src/jsx/auxiliary/string.rs b/crates/rome_js_formatter/src/jsx/auxiliary/string.rs index 099d176e9c9..f3dc7b7b9b1 100644 --- a/crates/rome_js_formatter/src/jsx/auxiliary/string.rs +++ b/crates/rome_js_formatter/src/jsx/auxiliary/string.rs @@ -4,7 +4,7 @@ use rome_formatter::write; use rome_js_syntax::JsxString; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsxString, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsxString, f: &mut JsFormatter) -> FormatResult<()> { write![f, [node.value_token().format()]] } } diff --git a/crates/rome_js_formatter/src/jsx/auxiliary/text.rs b/crates/rome_js_formatter/src/jsx/auxiliary/text.rs index def3d03cbc3..7ff1511b29d 100644 --- a/crates/rome_js_formatter/src/jsx/auxiliary/text.rs +++ b/crates/rome_js_formatter/src/jsx/auxiliary/text.rs @@ -8,7 +8,7 @@ use std::ops::Range; use std::str::CharIndices; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsxText, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsxText, f: &mut JsFormatter) -> FormatResult<()> { let JsxTextFields { value_token } = node.as_fields(); let token = value_token?; let new_text = clean_jsx_text(token.text()); diff --git a/crates/rome_js_formatter/src/jsx/expressions/tag_expression.rs b/crates/rome_js_formatter/src/jsx/expressions/tag_expression.rs index b9e2e97ad25..43a5f0bb360 100644 --- a/crates/rome_js_formatter/src/jsx/expressions/tag_expression.rs +++ b/crates/rome_js_formatter/src/jsx/expressions/tag_expression.rs @@ -4,7 +4,7 @@ use rome_formatter::write; use rome_js_syntax::JsxTagExpression; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsxTagExpression, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsxTagExpression, f: &mut JsFormatter) -> FormatResult<()> { write![f, [node.tag().format()]] } } diff --git a/crates/rome_js_formatter/src/jsx/lists/attribute_list.rs b/crates/rome_js_formatter/src/jsx/lists/attribute_list.rs index dce4b54447d..09e544cc28f 100644 --- a/crates/rome_js_formatter/src/jsx/lists/attribute_list.rs +++ b/crates/rome_js_formatter/src/jsx/lists/attribute_list.rs @@ -6,13 +6,13 @@ use rome_js_syntax::JsxAttributeList; impl FormatRule for FormatJsxAttributeList { type Context = JsFormatContext; - fn format(node: &JsxAttributeList, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &JsxAttributeList, f: &mut JsFormatter) -> FormatResult<()> { let attributes = format_with(|f| { - f.join_with(soft_line_break_or_space()) + f.join_with(&soft_line_break_or_space()) .entries(node.iter().formatted()) .finish() }); - write!(f, [group_elements(soft_block_indent(attributes))]) + write!(f, [group_elements(&soft_block_indent(&attributes))]) } } diff --git a/crates/rome_js_formatter/src/jsx/lists/child_list.rs b/crates/rome_js_formatter/src/jsx/lists/child_list.rs index 13eef78bf01..a3fc7fc0f32 100644 --- a/crates/rome_js_formatter/src/jsx/lists/child_list.rs +++ b/crates/rome_js_formatter/src/jsx/lists/child_list.rs @@ -6,7 +6,7 @@ use rome_rowan::AstNode; impl FormatRule for FormatJsxChildList { type Context = JsFormatContext; - fn format(node: &JsxChildList, formatter: &mut JsFormatter) -> FormatResult<()> { - format_verbatim_node(node.syntax()).format(formatter) + fn fmt(node: &JsxChildList, formatter: &mut JsFormatter) -> FormatResult<()> { + format_verbatim_node(node.syntax()).fmt(formatter) } } diff --git a/crates/rome_js_formatter/src/jsx/objects/member_name.rs b/crates/rome_js_formatter/src/jsx/objects/member_name.rs index 287857f0ce5..2e64469ccd9 100644 --- a/crates/rome_js_formatter/src/jsx/objects/member_name.rs +++ b/crates/rome_js_formatter/src/jsx/objects/member_name.rs @@ -4,7 +4,7 @@ use rome_formatter::write; use rome_js_syntax::{JsxMemberName, JsxMemberNameFields}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsxMemberName, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsxMemberName, f: &mut JsFormatter) -> FormatResult<()> { let JsxMemberNameFields { object, dot_token, diff --git a/crates/rome_js_formatter/src/jsx/tag/closing_element.rs b/crates/rome_js_formatter/src/jsx/tag/closing_element.rs index e87ea313d21..786f5aa0966 100644 --- a/crates/rome_js_formatter/src/jsx/tag/closing_element.rs +++ b/crates/rome_js_formatter/src/jsx/tag/closing_element.rs @@ -4,7 +4,7 @@ use rome_js_syntax::JsxClosingElement; use rome_rowan::AstNode; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsxClosingElement, formatter: &mut JsFormatter) -> FormatResult<()> { - format_verbatim_node(node.syntax()).format(formatter) + fn fmt_fields(node: &JsxClosingElement, formatter: &mut JsFormatter) -> FormatResult<()> { + format_verbatim_node(node.syntax()).fmt(formatter) } } diff --git a/crates/rome_js_formatter/src/jsx/tag/closing_fragment.rs b/crates/rome_js_formatter/src/jsx/tag/closing_fragment.rs index 331760d4994..1be3067b786 100644 --- a/crates/rome_js_formatter/src/jsx/tag/closing_fragment.rs +++ b/crates/rome_js_formatter/src/jsx/tag/closing_fragment.rs @@ -4,7 +4,7 @@ use rome_formatter::write; use rome_js_syntax::{JsxClosingFragment, JsxClosingFragmentFields}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsxClosingFragment, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsxClosingFragment, f: &mut JsFormatter) -> FormatResult<()> { let JsxClosingFragmentFields { r_angle_token, slash_token, diff --git a/crates/rome_js_formatter/src/jsx/tag/element.rs b/crates/rome_js_formatter/src/jsx/tag/element.rs index d0c597e0b68..0233f872758 100644 --- a/crates/rome_js_formatter/src/jsx/tag/element.rs +++ b/crates/rome_js_formatter/src/jsx/tag/element.rs @@ -4,7 +4,7 @@ use rome_js_syntax::JsxElement; use rome_rowan::AstNode; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsxElement, formatter: &mut JsFormatter) -> FormatResult<()> { - format_verbatim_node(node.syntax()).format(formatter) + fn fmt_fields(node: &JsxElement, formatter: &mut JsFormatter) -> FormatResult<()> { + format_verbatim_node(node.syntax()).fmt(formatter) } } diff --git a/crates/rome_js_formatter/src/jsx/tag/fragment.rs b/crates/rome_js_formatter/src/jsx/tag/fragment.rs index 1365d93960a..7a437722807 100644 --- a/crates/rome_js_formatter/src/jsx/tag/fragment.rs +++ b/crates/rome_js_formatter/src/jsx/tag/fragment.rs @@ -4,7 +4,7 @@ use rome_formatter::write; use rome_js_syntax::{JsxFragment, JsxFragmentFields}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsxFragment, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsxFragment, f: &mut JsFormatter) -> FormatResult<()> { let JsxFragmentFields { opening_fragment, children, diff --git a/crates/rome_js_formatter/src/jsx/tag/opening_element.rs b/crates/rome_js_formatter/src/jsx/tag/opening_element.rs index bd8bc519579..d5150eefcfd 100644 --- a/crates/rome_js_formatter/src/jsx/tag/opening_element.rs +++ b/crates/rome_js_formatter/src/jsx/tag/opening_element.rs @@ -4,7 +4,7 @@ use rome_js_syntax::JsxOpeningElement; use rome_rowan::AstNode; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsxOpeningElement, formatter: &mut JsFormatter) -> FormatResult<()> { - format_verbatim_node(node.syntax()).format(formatter) + fn fmt_fields(node: &JsxOpeningElement, formatter: &mut JsFormatter) -> FormatResult<()> { + format_verbatim_node(node.syntax()).fmt(formatter) } } diff --git a/crates/rome_js_formatter/src/jsx/tag/opening_fragment.rs b/crates/rome_js_formatter/src/jsx/tag/opening_fragment.rs index c277cf9582c..241bea427ef 100644 --- a/crates/rome_js_formatter/src/jsx/tag/opening_fragment.rs +++ b/crates/rome_js_formatter/src/jsx/tag/opening_fragment.rs @@ -4,7 +4,7 @@ use rome_formatter::write; use rome_js_syntax::{JsxOpeningFragment, JsxOpeningFragmentFields}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsxOpeningFragment, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsxOpeningFragment, f: &mut JsFormatter) -> FormatResult<()> { let JsxOpeningFragmentFields { r_angle_token, l_angle_token, diff --git a/crates/rome_js_formatter/src/jsx/tag/self_closing_element.rs b/crates/rome_js_formatter/src/jsx/tag/self_closing_element.rs index 69017fff5e1..b7b195ba785 100644 --- a/crates/rome_js_formatter/src/jsx/tag/self_closing_element.rs +++ b/crates/rome_js_formatter/src/jsx/tag/self_closing_element.rs @@ -4,7 +4,7 @@ use rome_formatter::write; use rome_js_syntax::{JsxSelfClosingElement, JsxSelfClosingElementFields}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &JsxSelfClosingElement, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &JsxSelfClosingElement, f: &mut JsFormatter) -> FormatResult<()> { let JsxSelfClosingElementFields { l_angle_token, name, diff --git a/crates/rome_js_formatter/src/lib.rs b/crates/rome_js_formatter/src/lib.rs index c1022b9cfc3..f2b382b2c1d 100644 --- a/crates/rome_js_formatter/src/lib.rs +++ b/crates/rome_js_formatter/src/lib.rs @@ -181,12 +181,12 @@ where { type Context = JsFormatContext; - fn format(node: &N, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &N, f: &mut JsFormatter) -> FormatResult<()> { let syntax = node.syntax(); if has_formatter_suppressions(syntax) { write!(f, [format_suppressed_node(syntax)])?; } else { - Self::format_fields(node, f)?; + Self::fmt_fields(node, f)?; }; Ok(()) @@ -198,7 +198,7 @@ where T: AstNode, { /// Formats the node's fields. - fn format_fields(item: &T, f: &mut JsFormatter) -> FormatResult<()>; + fn fmt_fields(item: &T, f: &mut JsFormatter) -> FormatResult<()>; } /// Format implementation specific to JavaScript tokens. @@ -207,7 +207,7 @@ pub struct FormatJsSyntaxToken; impl FormatRule for FormatJsSyntaxToken { type Context = JsFormatContext; - fn format(token: &JsSyntaxToken, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(token: &JsSyntaxToken, f: &mut JsFormatter) -> FormatResult<()> { f.state_mut().track_token(token); write!( @@ -485,11 +485,11 @@ mod test { use rome_js_parser::parse; use rome_js_syntax::SourceType; - #[test] #[ignore] + #[test] // use this test check if your snippet prints as you wish, without using a snapshot fn quick_test() { - let src = r#"one.two.tree"#; + let src = r#"if (true) {}"#; let syntax = SourceType::tsx(); let tree = parse(src, 0, syntax); let result = format_node(JsFormatContext::default(), &tree.syntax()) diff --git a/crates/rome_js_formatter/src/separated.rs b/crates/rome_js_formatter/src/separated.rs index 0f4dbd1794b..9c055b56119 100644 --- a/crates/rome_js_formatter/src/separated.rs +++ b/crates/rome_js_formatter/src/separated.rs @@ -22,11 +22,11 @@ where for<'a> N: AstNode + AsFormat<'a>, Separator: Format, { - fn format(&self, f: &mut Formatter) -> FormatResult<()> { + fn fmt(&self, f: &mut Formatter) -> FormatResult<()> { let node = self.element.node()?; let separator = self.element.trailing_separator()?; - write!(f, [group_elements(node.format())])?; + write!(f, [group_elements(&node.format())])?; let format_trailing_separator = if_group_breaks(&self.separator).with_group_id(self.options.group_id); diff --git a/crates/rome_js_formatter/src/ts/any/external_module_declaration_body.rs b/crates/rome_js_formatter/src/ts/any/external_module_declaration_body.rs index d1ececbc678..580dc95476e 100644 --- a/crates/rome_js_formatter/src/ts/any/external_module_declaration_body.rs +++ b/crates/rome_js_formatter/src/ts/any/external_module_declaration_body.rs @@ -5,12 +5,12 @@ use crate::prelude::*; use rome_js_syntax::TsAnyExternalModuleDeclarationBody; impl FormatRule for FormatTsAnyExternalModuleDeclarationBody { type Context = JsFormatContext; - fn format(node: &TsAnyExternalModuleDeclarationBody, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &TsAnyExternalModuleDeclarationBody, f: &mut JsFormatter) -> FormatResult<()> { match node { TsAnyExternalModuleDeclarationBody::TsEmptyExternalModuleDeclarationBody(node) => { - node.format().format(f) + node.format().fmt(f) } - TsAnyExternalModuleDeclarationBody::TsModuleBlock(node) => node.format().format(f), + TsAnyExternalModuleDeclarationBody::TsModuleBlock(node) => node.format().fmt(f), } } } diff --git a/crates/rome_js_formatter/src/ts/any/index_signature_modifier.rs b/crates/rome_js_formatter/src/ts/any/index_signature_modifier.rs index 93af0d4d8be..c6326aba7a4 100644 --- a/crates/rome_js_formatter/src/ts/any/index_signature_modifier.rs +++ b/crates/rome_js_formatter/src/ts/any/index_signature_modifier.rs @@ -5,10 +5,10 @@ use crate::prelude::*; use rome_js_syntax::TsAnyIndexSignatureModifier; impl FormatRule for FormatTsAnyIndexSignatureModifier { type Context = JsFormatContext; - fn format(node: &TsAnyIndexSignatureModifier, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &TsAnyIndexSignatureModifier, f: &mut JsFormatter) -> FormatResult<()> { match node { - TsAnyIndexSignatureModifier::JsStaticModifier(node) => node.format().format(f), - TsAnyIndexSignatureModifier::TsReadonlyModifier(node) => node.format().format(f), + TsAnyIndexSignatureModifier::JsStaticModifier(node) => node.format().fmt(f), + TsAnyIndexSignatureModifier::TsReadonlyModifier(node) => node.format().fmt(f), } } } diff --git a/crates/rome_js_formatter/src/ts/any/method_signature_modifier.rs b/crates/rome_js_formatter/src/ts/any/method_signature_modifier.rs index 895e7e07fc2..142ccf07eaf 100644 --- a/crates/rome_js_formatter/src/ts/any/method_signature_modifier.rs +++ b/crates/rome_js_formatter/src/ts/any/method_signature_modifier.rs @@ -5,12 +5,12 @@ use crate::prelude::*; use rome_js_syntax::TsAnyMethodSignatureModifier; impl FormatRule for FormatTsAnyMethodSignatureModifier { type Context = JsFormatContext; - fn format(node: &TsAnyMethodSignatureModifier, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &TsAnyMethodSignatureModifier, f: &mut JsFormatter) -> FormatResult<()> { match node { - TsAnyMethodSignatureModifier::TsAccessibilityModifier(node) => node.format().format(f), - TsAnyMethodSignatureModifier::JsStaticModifier(node) => node.format().format(f), - TsAnyMethodSignatureModifier::TsOverrideModifier(node) => node.format().format(f), - TsAnyMethodSignatureModifier::TsAbstractModifier(node) => node.format().format(f), + TsAnyMethodSignatureModifier::TsAccessibilityModifier(node) => node.format().fmt(f), + TsAnyMethodSignatureModifier::JsStaticModifier(node) => node.format().fmt(f), + TsAnyMethodSignatureModifier::TsOverrideModifier(node) => node.format().fmt(f), + TsAnyMethodSignatureModifier::TsAbstractModifier(node) => node.format().fmt(f), } } } diff --git a/crates/rome_js_formatter/src/ts/any/module_name.rs b/crates/rome_js_formatter/src/ts/any/module_name.rs index c2d07cb954b..160c8a38464 100644 --- a/crates/rome_js_formatter/src/ts/any/module_name.rs +++ b/crates/rome_js_formatter/src/ts/any/module_name.rs @@ -5,10 +5,10 @@ use crate::prelude::*; use rome_js_syntax::TsAnyModuleName; impl FormatRule for FormatTsAnyModuleName { type Context = JsFormatContext; - fn format(node: &TsAnyModuleName, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &TsAnyModuleName, f: &mut JsFormatter) -> FormatResult<()> { match node { - TsAnyModuleName::TsIdentifierBinding(node) => node.format().format(f), - TsAnyModuleName::TsQualifiedModuleName(node) => node.format().format(f), + TsAnyModuleName::TsIdentifierBinding(node) => node.format().fmt(f), + TsAnyModuleName::TsQualifiedModuleName(node) => node.format().fmt(f), } } } diff --git a/crates/rome_js_formatter/src/ts/any/module_reference.rs b/crates/rome_js_formatter/src/ts/any/module_reference.rs index f7862488314..cd5841c06bf 100644 --- a/crates/rome_js_formatter/src/ts/any/module_reference.rs +++ b/crates/rome_js_formatter/src/ts/any/module_reference.rs @@ -5,10 +5,10 @@ use crate::prelude::*; use rome_js_syntax::TsAnyModuleReference; impl FormatRule for FormatTsAnyModuleReference { type Context = JsFormatContext; - fn format(node: &TsAnyModuleReference, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &TsAnyModuleReference, f: &mut JsFormatter) -> FormatResult<()> { match node { - TsAnyModuleReference::TsAnyName(node) => node.format().format(f), - TsAnyModuleReference::TsExternalModuleReference(node) => node.format().format(f), + TsAnyModuleReference::TsAnyName(node) => node.format().fmt(f), + TsAnyModuleReference::TsExternalModuleReference(node) => node.format().fmt(f), } } } diff --git a/crates/rome_js_formatter/src/ts/any/name.rs b/crates/rome_js_formatter/src/ts/any/name.rs index 333dfed02e1..0bf9a1f2018 100644 --- a/crates/rome_js_formatter/src/ts/any/name.rs +++ b/crates/rome_js_formatter/src/ts/any/name.rs @@ -5,10 +5,10 @@ use crate::prelude::*; use rome_js_syntax::TsAnyName; impl FormatRule for FormatTsAnyName { type Context = JsFormatContext; - fn format(node: &TsAnyName, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &TsAnyName, f: &mut JsFormatter) -> FormatResult<()> { match node { - TsAnyName::JsReferenceIdentifier(node) => node.format().format(f), - TsAnyName::TsQualifiedName(node) => node.format().format(f), + TsAnyName::JsReferenceIdentifier(node) => node.format().fmt(f), + TsAnyName::TsQualifiedName(node) => node.format().fmt(f), } } } diff --git a/crates/rome_js_formatter/src/ts/any/property_annotation.rs b/crates/rome_js_formatter/src/ts/any/property_annotation.rs index 5d5942a9cfc..6c9da1e7af9 100644 --- a/crates/rome_js_formatter/src/ts/any/property_annotation.rs +++ b/crates/rome_js_formatter/src/ts/any/property_annotation.rs @@ -5,11 +5,11 @@ use crate::prelude::*; use rome_js_syntax::TsAnyPropertyAnnotation; impl FormatRule for FormatTsAnyPropertyAnnotation { type Context = JsFormatContext; - fn format(node: &TsAnyPropertyAnnotation, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &TsAnyPropertyAnnotation, f: &mut JsFormatter) -> FormatResult<()> { match node { - TsAnyPropertyAnnotation::TsTypeAnnotation(node) => node.format().format(f), - TsAnyPropertyAnnotation::TsOptionalPropertyAnnotation(node) => node.format().format(f), - TsAnyPropertyAnnotation::TsDefinitePropertyAnnotation(node) => node.format().format(f), + TsAnyPropertyAnnotation::TsTypeAnnotation(node) => node.format().fmt(f), + TsAnyPropertyAnnotation::TsOptionalPropertyAnnotation(node) => node.format().fmt(f), + TsAnyPropertyAnnotation::TsDefinitePropertyAnnotation(node) => node.format().fmt(f), } } } diff --git a/crates/rome_js_formatter/src/ts/any/property_parameter_modifier.rs b/crates/rome_js_formatter/src/ts/any/property_parameter_modifier.rs index 807d314f60b..b02a8ab2b99 100644 --- a/crates/rome_js_formatter/src/ts/any/property_parameter_modifier.rs +++ b/crates/rome_js_formatter/src/ts/any/property_parameter_modifier.rs @@ -5,13 +5,11 @@ use crate::prelude::*; use rome_js_syntax::TsAnyPropertyParameterModifier; impl FormatRule for FormatTsAnyPropertyParameterModifier { type Context = JsFormatContext; - fn format(node: &TsAnyPropertyParameterModifier, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &TsAnyPropertyParameterModifier, f: &mut JsFormatter) -> FormatResult<()> { match node { - TsAnyPropertyParameterModifier::TsAccessibilityModifier(node) => { - node.format().format(f) - } - TsAnyPropertyParameterModifier::TsReadonlyModifier(node) => node.format().format(f), - TsAnyPropertyParameterModifier::TsOverrideModifier(node) => node.format().format(f), + TsAnyPropertyParameterModifier::TsAccessibilityModifier(node) => node.format().fmt(f), + TsAnyPropertyParameterModifier::TsReadonlyModifier(node) => node.format().fmt(f), + TsAnyPropertyParameterModifier::TsOverrideModifier(node) => node.format().fmt(f), } } } diff --git a/crates/rome_js_formatter/src/ts/any/property_signature_annotation.rs b/crates/rome_js_formatter/src/ts/any/property_signature_annotation.rs index 04f3e7edfa0..aa6546fb5d1 100644 --- a/crates/rome_js_formatter/src/ts/any/property_signature_annotation.rs +++ b/crates/rome_js_formatter/src/ts/any/property_signature_annotation.rs @@ -5,11 +5,11 @@ use crate::prelude::*; use rome_js_syntax::TsAnyPropertySignatureAnnotation; impl FormatRule for FormatTsAnyPropertySignatureAnnotation { type Context = JsFormatContext; - fn format(node: &TsAnyPropertySignatureAnnotation, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &TsAnyPropertySignatureAnnotation, f: &mut JsFormatter) -> FormatResult<()> { match node { - TsAnyPropertySignatureAnnotation::TsTypeAnnotation(node) => node.format().format(f), + TsAnyPropertySignatureAnnotation::TsTypeAnnotation(node) => node.format().fmt(f), TsAnyPropertySignatureAnnotation::TsOptionalPropertyAnnotation(node) => { - node.format().format(f) + node.format().fmt(f) } } } diff --git a/crates/rome_js_formatter/src/ts/any/property_signature_modifier.rs b/crates/rome_js_formatter/src/ts/any/property_signature_modifier.rs index c9ba596b239..37274ec85de 100644 --- a/crates/rome_js_formatter/src/ts/any/property_signature_modifier.rs +++ b/crates/rome_js_formatter/src/ts/any/property_signature_modifier.rs @@ -5,16 +5,14 @@ use crate::prelude::*; use rome_js_syntax::TsAnyPropertySignatureModifier; impl FormatRule for FormatTsAnyPropertySignatureModifier { type Context = JsFormatContext; - fn format(node: &TsAnyPropertySignatureModifier, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &TsAnyPropertySignatureModifier, f: &mut JsFormatter) -> FormatResult<()> { match node { - TsAnyPropertySignatureModifier::TsDeclareModifier(node) => node.format().format(f), - TsAnyPropertySignatureModifier::TsAccessibilityModifier(node) => { - node.format().format(f) - } - TsAnyPropertySignatureModifier::JsStaticModifier(node) => node.format().format(f), - TsAnyPropertySignatureModifier::TsReadonlyModifier(node) => node.format().format(f), - TsAnyPropertySignatureModifier::TsOverrideModifier(node) => node.format().format(f), - TsAnyPropertySignatureModifier::TsAbstractModifier(node) => node.format().format(f), + TsAnyPropertySignatureModifier::TsDeclareModifier(node) => node.format().fmt(f), + TsAnyPropertySignatureModifier::TsAccessibilityModifier(node) => node.format().fmt(f), + TsAnyPropertySignatureModifier::JsStaticModifier(node) => node.format().fmt(f), + TsAnyPropertySignatureModifier::TsReadonlyModifier(node) => node.format().fmt(f), + TsAnyPropertySignatureModifier::TsOverrideModifier(node) => node.format().fmt(f), + TsAnyPropertySignatureModifier::TsAbstractModifier(node) => node.format().fmt(f), } } } diff --git a/crates/rome_js_formatter/src/ts/any/return_type.rs b/crates/rome_js_formatter/src/ts/any/return_type.rs index 45ab6dbbb35..04c3c7b8f99 100644 --- a/crates/rome_js_formatter/src/ts/any/return_type.rs +++ b/crates/rome_js_formatter/src/ts/any/return_type.rs @@ -5,11 +5,11 @@ use crate::prelude::*; use rome_js_syntax::TsAnyReturnType; impl FormatRule for FormatTsAnyReturnType { type Context = JsFormatContext; - fn format(node: &TsAnyReturnType, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &TsAnyReturnType, f: &mut JsFormatter) -> FormatResult<()> { match node { - TsAnyReturnType::TsType(node) => node.format().format(f), - TsAnyReturnType::TsPredicateReturnType(node) => node.format().format(f), - TsAnyReturnType::TsAssertsReturnType(node) => node.format().format(f), + TsAnyReturnType::TsType(node) => node.format().fmt(f), + TsAnyReturnType::TsPredicateReturnType(node) => node.format().fmt(f), + TsAnyReturnType::TsAssertsReturnType(node) => node.format().fmt(f), } } } diff --git a/crates/rome_js_formatter/src/ts/any/template_element.rs b/crates/rome_js_formatter/src/ts/any/template_element.rs index 862c54419cf..3c5b4d07897 100644 --- a/crates/rome_js_formatter/src/ts/any/template_element.rs +++ b/crates/rome_js_formatter/src/ts/any/template_element.rs @@ -5,10 +5,10 @@ use crate::prelude::*; use rome_js_syntax::TsAnyTemplateElement; impl FormatRule for FormatTsAnyTemplateElement { type Context = JsFormatContext; - fn format(node: &TsAnyTemplateElement, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &TsAnyTemplateElement, f: &mut JsFormatter) -> FormatResult<()> { match node { - TsAnyTemplateElement::TsTemplateChunkElement(node) => node.format().format(f), - TsAnyTemplateElement::TsTemplateElement(node) => node.format().format(f), + TsAnyTemplateElement::TsTemplateChunkElement(node) => node.format().fmt(f), + TsAnyTemplateElement::TsTemplateElement(node) => node.format().fmt(f), } } } diff --git a/crates/rome_js_formatter/src/ts/any/ts_type.rs b/crates/rome_js_formatter/src/ts/any/ts_type.rs index a0c625654f7..428e5f5c475 100644 --- a/crates/rome_js_formatter/src/ts/any/ts_type.rs +++ b/crates/rome_js_formatter/src/ts/any/ts_type.rs @@ -5,42 +5,42 @@ use crate::prelude::*; use rome_js_syntax::TsType; impl FormatRule for FormatTsType { type Context = JsFormatContext; - fn format(node: &TsType, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &TsType, f: &mut JsFormatter) -> FormatResult<()> { match node { - TsType::TsAnyType(node) => node.format().format(f), - TsType::TsUnknownType(node) => node.format().format(f), - TsType::TsNumberType(node) => node.format().format(f), - TsType::TsBooleanType(node) => node.format().format(f), - TsType::TsBigintType(node) => node.format().format(f), - TsType::TsStringType(node) => node.format().format(f), - TsType::TsSymbolType(node) => node.format().format(f), - TsType::TsVoidType(node) => node.format().format(f), - TsType::TsUndefinedType(node) => node.format().format(f), - TsType::TsNeverType(node) => node.format().format(f), - TsType::TsParenthesizedType(node) => node.format().format(f), - TsType::TsReferenceType(node) => node.format().format(f), - TsType::TsArrayType(node) => node.format().format(f), - TsType::TsTupleType(node) => node.format().format(f), - TsType::TsTypeofType(node) => node.format().format(f), - TsType::TsImportType(node) => node.format().format(f), - TsType::TsTypeOperatorType(node) => node.format().format(f), - TsType::TsIndexedAccessType(node) => node.format().format(f), - TsType::TsMappedType(node) => node.format().format(f), - TsType::TsObjectType(node) => node.format().format(f), - TsType::TsNonPrimitiveType(node) => node.format().format(f), - TsType::TsThisType(node) => node.format().format(f), - TsType::TsNumberLiteralType(node) => node.format().format(f), - TsType::TsBigIntLiteralType(node) => node.format().format(f), - TsType::TsStringLiteralType(node) => node.format().format(f), - TsType::TsNullLiteralType(node) => node.format().format(f), - TsType::TsBooleanLiteralType(node) => node.format().format(f), - TsType::TsTemplateLiteralType(node) => node.format().format(f), - TsType::TsInferType(node) => node.format().format(f), - TsType::TsIntersectionType(node) => node.format().format(f), - TsType::TsUnionType(node) => node.format().format(f), - TsType::TsFunctionType(node) => node.format().format(f), - TsType::TsConstructorType(node) => node.format().format(f), - TsType::TsConditionalType(node) => node.format().format(f), + TsType::TsAnyType(node) => node.format().fmt(f), + TsType::TsUnknownType(node) => node.format().fmt(f), + TsType::TsNumberType(node) => node.format().fmt(f), + TsType::TsBooleanType(node) => node.format().fmt(f), + TsType::TsBigintType(node) => node.format().fmt(f), + TsType::TsStringType(node) => node.format().fmt(f), + TsType::TsSymbolType(node) => node.format().fmt(f), + TsType::TsVoidType(node) => node.format().fmt(f), + TsType::TsUndefinedType(node) => node.format().fmt(f), + TsType::TsNeverType(node) => node.format().fmt(f), + TsType::TsParenthesizedType(node) => node.format().fmt(f), + TsType::TsReferenceType(node) => node.format().fmt(f), + TsType::TsArrayType(node) => node.format().fmt(f), + TsType::TsTupleType(node) => node.format().fmt(f), + TsType::TsTypeofType(node) => node.format().fmt(f), + TsType::TsImportType(node) => node.format().fmt(f), + TsType::TsTypeOperatorType(node) => node.format().fmt(f), + TsType::TsIndexedAccessType(node) => node.format().fmt(f), + TsType::TsMappedType(node) => node.format().fmt(f), + TsType::TsObjectType(node) => node.format().fmt(f), + TsType::TsNonPrimitiveType(node) => node.format().fmt(f), + TsType::TsThisType(node) => node.format().fmt(f), + TsType::TsNumberLiteralType(node) => node.format().fmt(f), + TsType::TsBigIntLiteralType(node) => node.format().fmt(f), + TsType::TsStringLiteralType(node) => node.format().fmt(f), + TsType::TsNullLiteralType(node) => node.format().fmt(f), + TsType::TsBooleanLiteralType(node) => node.format().fmt(f), + TsType::TsTemplateLiteralType(node) => node.format().fmt(f), + TsType::TsInferType(node) => node.format().fmt(f), + TsType::TsIntersectionType(node) => node.format().fmt(f), + TsType::TsUnionType(node) => node.format().fmt(f), + TsType::TsFunctionType(node) => node.format().fmt(f), + TsType::TsConstructorType(node) => node.format().fmt(f), + TsType::TsConditionalType(node) => node.format().fmt(f), } } } diff --git a/crates/rome_js_formatter/src/ts/any/tuple_type_element.rs b/crates/rome_js_formatter/src/ts/any/tuple_type_element.rs index aea446a2349..ac53f19609f 100644 --- a/crates/rome_js_formatter/src/ts/any/tuple_type_element.rs +++ b/crates/rome_js_formatter/src/ts/any/tuple_type_element.rs @@ -5,12 +5,12 @@ use crate::prelude::*; use rome_js_syntax::TsAnyTupleTypeElement; impl FormatRule for FormatTsAnyTupleTypeElement { type Context = JsFormatContext; - fn format(node: &TsAnyTupleTypeElement, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &TsAnyTupleTypeElement, f: &mut JsFormatter) -> FormatResult<()> { match node { - TsAnyTupleTypeElement::TsNamedTupleTypeElement(node) => node.format().format(f), - TsAnyTupleTypeElement::TsType(node) => node.format().format(f), - TsAnyTupleTypeElement::TsRestTupleTypeElement(node) => node.format().format(f), - TsAnyTupleTypeElement::TsOptionalTupleTypeElement(node) => node.format().format(f), + TsAnyTupleTypeElement::TsNamedTupleTypeElement(node) => node.format().fmt(f), + TsAnyTupleTypeElement::TsType(node) => node.format().fmt(f), + TsAnyTupleTypeElement::TsRestTupleTypeElement(node) => node.format().fmt(f), + TsAnyTupleTypeElement::TsOptionalTupleTypeElement(node) => node.format().fmt(f), } } } diff --git a/crates/rome_js_formatter/src/ts/any/type_member.rs b/crates/rome_js_formatter/src/ts/any/type_member.rs index 4b415b5cbfa..54a47a4f4e4 100644 --- a/crates/rome_js_formatter/src/ts/any/type_member.rs +++ b/crates/rome_js_formatter/src/ts/any/type_member.rs @@ -5,16 +5,16 @@ use crate::prelude::*; use rome_js_syntax::TsAnyTypeMember; impl FormatRule for FormatTsAnyTypeMember { type Context = JsFormatContext; - fn format(node: &TsAnyTypeMember, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &TsAnyTypeMember, f: &mut JsFormatter) -> FormatResult<()> { match node { - TsAnyTypeMember::TsCallSignatureTypeMember(node) => node.format().format(f), - TsAnyTypeMember::TsPropertySignatureTypeMember(node) => node.format().format(f), - TsAnyTypeMember::TsConstructSignatureTypeMember(node) => node.format().format(f), - TsAnyTypeMember::TsMethodSignatureTypeMember(node) => node.format().format(f), - TsAnyTypeMember::TsGetterSignatureTypeMember(node) => node.format().format(f), - TsAnyTypeMember::TsSetterSignatureTypeMember(node) => node.format().format(f), - TsAnyTypeMember::TsIndexSignatureTypeMember(node) => node.format().format(f), - TsAnyTypeMember::JsUnknownMember(node) => node.format().format(f), + TsAnyTypeMember::TsCallSignatureTypeMember(node) => node.format().fmt(f), + TsAnyTypeMember::TsPropertySignatureTypeMember(node) => node.format().fmt(f), + TsAnyTypeMember::TsConstructSignatureTypeMember(node) => node.format().fmt(f), + TsAnyTypeMember::TsMethodSignatureTypeMember(node) => node.format().fmt(f), + TsAnyTypeMember::TsGetterSignatureTypeMember(node) => node.format().fmt(f), + TsAnyTypeMember::TsSetterSignatureTypeMember(node) => node.format().fmt(f), + TsAnyTypeMember::TsIndexSignatureTypeMember(node) => node.format().fmt(f), + TsAnyTypeMember::JsUnknownMember(node) => node.format().fmt(f), } } } diff --git a/crates/rome_js_formatter/src/ts/any/type_predicate_parameter_name.rs b/crates/rome_js_formatter/src/ts/any/type_predicate_parameter_name.rs index e424e8fe902..9be89c54c4d 100644 --- a/crates/rome_js_formatter/src/ts/any/type_predicate_parameter_name.rs +++ b/crates/rome_js_formatter/src/ts/any/type_predicate_parameter_name.rs @@ -5,10 +5,10 @@ use crate::prelude::*; use rome_js_syntax::TsAnyTypePredicateParameterName; impl FormatRule for FormatTsAnyTypePredicateParameterName { type Context = JsFormatContext; - fn format(node: &TsAnyTypePredicateParameterName, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &TsAnyTypePredicateParameterName, f: &mut JsFormatter) -> FormatResult<()> { match node { - TsAnyTypePredicateParameterName::JsReferenceIdentifier(node) => node.format().format(f), - TsAnyTypePredicateParameterName::TsThisType(node) => node.format().format(f), + TsAnyTypePredicateParameterName::JsReferenceIdentifier(node) => node.format().fmt(f), + TsAnyTypePredicateParameterName::TsThisType(node) => node.format().fmt(f), } } } diff --git a/crates/rome_js_formatter/src/ts/any/variable_annotation.rs b/crates/rome_js_formatter/src/ts/any/variable_annotation.rs index e5a214eaf97..3c5134b34d4 100644 --- a/crates/rome_js_formatter/src/ts/any/variable_annotation.rs +++ b/crates/rome_js_formatter/src/ts/any/variable_annotation.rs @@ -5,10 +5,10 @@ use crate::prelude::*; use rome_js_syntax::TsAnyVariableAnnotation; impl FormatRule for FormatTsAnyVariableAnnotation { type Context = JsFormatContext; - fn format(node: &TsAnyVariableAnnotation, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &TsAnyVariableAnnotation, f: &mut JsFormatter) -> FormatResult<()> { match node { - TsAnyVariableAnnotation::TsTypeAnnotation(node) => node.format().format(f), - TsAnyVariableAnnotation::TsDefiniteVariableAnnotation(node) => node.format().format(f), + TsAnyVariableAnnotation::TsTypeAnnotation(node) => node.format().fmt(f), + TsAnyVariableAnnotation::TsDefiniteVariableAnnotation(node) => node.format().fmt(f), } } } diff --git a/crates/rome_js_formatter/src/ts/assignments/as_assignment.rs b/crates/rome_js_formatter/src/ts/assignments/as_assignment.rs index 3f1dc5f9174..27bea467c56 100644 --- a/crates/rome_js_formatter/src/ts/assignments/as_assignment.rs +++ b/crates/rome_js_formatter/src/ts/assignments/as_assignment.rs @@ -5,7 +5,7 @@ use rome_js_syntax::TsAsAssignment; use rome_js_syntax::TsAsAssignmentFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsAsAssignment, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsAsAssignment, f: &mut JsFormatter) -> FormatResult<()> { let TsAsAssignmentFields { assignment, as_token, diff --git a/crates/rome_js_formatter/src/ts/assignments/non_null_assertion_assignment.rs b/crates/rome_js_formatter/src/ts/assignments/non_null_assertion_assignment.rs index 67aef8e2b42..7b8be795d34 100644 --- a/crates/rome_js_formatter/src/ts/assignments/non_null_assertion_assignment.rs +++ b/crates/rome_js_formatter/src/ts/assignments/non_null_assertion_assignment.rs @@ -7,7 +7,7 @@ use rome_js_syntax::TsNonNullAssertionAssignmentFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsNonNullAssertionAssignment, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsNonNullAssertionAssignment, f: &mut JsFormatter) -> FormatResult<()> { let TsNonNullAssertionAssignmentFields { assignment, excl_token, diff --git a/crates/rome_js_formatter/src/ts/assignments/type_assertion_assignment.rs b/crates/rome_js_formatter/src/ts/assignments/type_assertion_assignment.rs index 62319571014..9dfc3cb5029 100644 --- a/crates/rome_js_formatter/src/ts/assignments/type_assertion_assignment.rs +++ b/crates/rome_js_formatter/src/ts/assignments/type_assertion_assignment.rs @@ -6,7 +6,7 @@ use crate::FormatNodeFields; use rome_js_syntax::TsTypeAssertionAssignment; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsTypeAssertionAssignment, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsTypeAssertionAssignment, f: &mut JsFormatter) -> FormatResult<()> { let TsTypeAssertionAssignmentFields { l_angle_token, ty, diff --git a/crates/rome_js_formatter/src/ts/auxiliary/abstract_modifier.rs b/crates/rome_js_formatter/src/ts/auxiliary/abstract_modifier.rs index d2f19341e32..ec9bb8ff35b 100644 --- a/crates/rome_js_formatter/src/ts/auxiliary/abstract_modifier.rs +++ b/crates/rome_js_formatter/src/ts/auxiliary/abstract_modifier.rs @@ -5,7 +5,7 @@ use rome_js_syntax::TsAbstractModifier; use rome_js_syntax::TsAbstractModifierFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsAbstractModifier, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsAbstractModifier, f: &mut JsFormatter) -> FormatResult<()> { let TsAbstractModifierFields { modifier_token } = node.as_fields(); write![f, [modifier_token.format()]] diff --git a/crates/rome_js_formatter/src/ts/auxiliary/accessibility_modifier.rs b/crates/rome_js_formatter/src/ts/auxiliary/accessibility_modifier.rs index f695fbb9fef..abebce0ff07 100644 --- a/crates/rome_js_formatter/src/ts/auxiliary/accessibility_modifier.rs +++ b/crates/rome_js_formatter/src/ts/auxiliary/accessibility_modifier.rs @@ -5,7 +5,7 @@ use rome_js_syntax::TsAccessibilityModifier; use rome_js_syntax::TsAccessibilityModifierFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsAccessibilityModifier, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsAccessibilityModifier, f: &mut JsFormatter) -> FormatResult<()> { let TsAccessibilityModifierFields { modifier_token } = node.as_fields(); write![f, [modifier_token.format()]] diff --git a/crates/rome_js_formatter/src/ts/auxiliary/asserts_condition.rs b/crates/rome_js_formatter/src/ts/auxiliary/asserts_condition.rs index a567a3bd7c0..5133d783fe0 100644 --- a/crates/rome_js_formatter/src/ts/auxiliary/asserts_condition.rs +++ b/crates/rome_js_formatter/src/ts/auxiliary/asserts_condition.rs @@ -5,7 +5,7 @@ use rome_js_syntax::TsAssertsCondition; use rome_js_syntax::TsAssertsConditionFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsAssertsCondition, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsAssertsCondition, f: &mut JsFormatter) -> FormatResult<()> { let TsAssertsConditionFields { is_token, ty } = node.as_fields(); write![f, [is_token.format(), space_token(), ty.format()]] } diff --git a/crates/rome_js_formatter/src/ts/auxiliary/call_signature_type_member.rs b/crates/rome_js_formatter/src/ts/auxiliary/call_signature_type_member.rs index e9501f0c06e..b8420e8b9aa 100644 --- a/crates/rome_js_formatter/src/ts/auxiliary/call_signature_type_member.rs +++ b/crates/rome_js_formatter/src/ts/auxiliary/call_signature_type_member.rs @@ -5,7 +5,7 @@ use rome_formatter::write; use rome_js_syntax::{TsCallSignatureTypeMember, TsCallSignatureTypeMemberFields}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsCallSignatureTypeMember, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsCallSignatureTypeMember, f: &mut JsFormatter) -> FormatResult<()> { let TsCallSignatureTypeMemberFields { type_parameters, parameters, diff --git a/crates/rome_js_formatter/src/ts/auxiliary/construct_signature_type_member.rs b/crates/rome_js_formatter/src/ts/auxiliary/construct_signature_type_member.rs index 9010a6d56c5..96e336e20df 100644 --- a/crates/rome_js_formatter/src/ts/auxiliary/construct_signature_type_member.rs +++ b/crates/rome_js_formatter/src/ts/auxiliary/construct_signature_type_member.rs @@ -8,10 +8,7 @@ use rome_js_syntax::{TsConstructSignatureTypeMember, TsConstructSignatureTypeMem impl FormatNodeFields for FormatNodeRule { - fn format_fields( - node: &TsConstructSignatureTypeMember, - f: &mut JsFormatter, - ) -> FormatResult<()> { + fn fmt_fields(node: &TsConstructSignatureTypeMember, f: &mut JsFormatter) -> FormatResult<()> { let TsConstructSignatureTypeMemberFields { new_token, type_parameters, diff --git a/crates/rome_js_formatter/src/ts/auxiliary/declare_modifier.rs b/crates/rome_js_formatter/src/ts/auxiliary/declare_modifier.rs index 3b40c1f4cfd..bd900010471 100644 --- a/crates/rome_js_formatter/src/ts/auxiliary/declare_modifier.rs +++ b/crates/rome_js_formatter/src/ts/auxiliary/declare_modifier.rs @@ -5,7 +5,7 @@ use rome_js_syntax::TsDeclareModifier; use rome_js_syntax::TsDeclareModifierFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsDeclareModifier, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsDeclareModifier, f: &mut JsFormatter) -> FormatResult<()> { let TsDeclareModifierFields { modifier_token } = node.as_fields(); write![f, [modifier_token.format()]] } diff --git a/crates/rome_js_formatter/src/ts/auxiliary/default_type_clause.rs b/crates/rome_js_formatter/src/ts/auxiliary/default_type_clause.rs index 2210b280254..fdbc7913be4 100644 --- a/crates/rome_js_formatter/src/ts/auxiliary/default_type_clause.rs +++ b/crates/rome_js_formatter/src/ts/auxiliary/default_type_clause.rs @@ -4,7 +4,7 @@ use rome_formatter::write; use rome_js_syntax::{TsDefaultTypeClause, TsDefaultTypeClauseFields}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsDefaultTypeClause, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsDefaultTypeClause, f: &mut JsFormatter) -> FormatResult<()> { let TsDefaultTypeClauseFields { eq_token, ty } = node.as_fields(); write![f, [eq_token.format(), space_token(), ty.format()]] } diff --git a/crates/rome_js_formatter/src/ts/auxiliary/definite_property_annotation.rs b/crates/rome_js_formatter/src/ts/auxiliary/definite_property_annotation.rs index f9ccd3428f1..67b81e363fe 100644 --- a/crates/rome_js_formatter/src/ts/auxiliary/definite_property_annotation.rs +++ b/crates/rome_js_formatter/src/ts/auxiliary/definite_property_annotation.rs @@ -7,7 +7,7 @@ use rome_js_syntax::TsDefinitePropertyAnnotationFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsDefinitePropertyAnnotation, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsDefinitePropertyAnnotation, f: &mut JsFormatter) -> FormatResult<()> { let TsDefinitePropertyAnnotationFields { excl_token, type_annotation, diff --git a/crates/rome_js_formatter/src/ts/auxiliary/definite_variable_annotation.rs b/crates/rome_js_formatter/src/ts/auxiliary/definite_variable_annotation.rs index 84c9953c0b7..974ddc0eaf1 100644 --- a/crates/rome_js_formatter/src/ts/auxiliary/definite_variable_annotation.rs +++ b/crates/rome_js_formatter/src/ts/auxiliary/definite_variable_annotation.rs @@ -7,7 +7,7 @@ use rome_js_syntax::TsDefiniteVariableAnnotationFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsDefiniteVariableAnnotation, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsDefiniteVariableAnnotation, f: &mut JsFormatter) -> FormatResult<()> { let TsDefiniteVariableAnnotationFields { excl_token, type_annotation, diff --git a/crates/rome_js_formatter/src/ts/auxiliary/empty_external_module_declaration_body.rs b/crates/rome_js_formatter/src/ts/auxiliary/empty_external_module_declaration_body.rs index c33738adfa9..3d7d349689e 100644 --- a/crates/rome_js_formatter/src/ts/auxiliary/empty_external_module_declaration_body.rs +++ b/crates/rome_js_formatter/src/ts/auxiliary/empty_external_module_declaration_body.rs @@ -7,7 +7,7 @@ use rome_js_syntax::TsEmptyExternalModuleDeclarationBodyFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields( + fn fmt_fields( node: &TsEmptyExternalModuleDeclarationBody, f: &mut JsFormatter, ) -> FormatResult<()> { diff --git a/crates/rome_js_formatter/src/ts/auxiliary/enum_member.rs b/crates/rome_js_formatter/src/ts/auxiliary/enum_member.rs index cd8bf466d1c..5d30079c096 100644 --- a/crates/rome_js_formatter/src/ts/auxiliary/enum_member.rs +++ b/crates/rome_js_formatter/src/ts/auxiliary/enum_member.rs @@ -5,7 +5,7 @@ use rome_formatter::write; use rome_js_syntax::{TsEnumMember, TsEnumMemberFields}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsEnumMember, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsEnumMember, f: &mut JsFormatter) -> FormatResult<()> { let TsEnumMemberFields { name, initializer } = node.as_fields(); write!( diff --git a/crates/rome_js_formatter/src/ts/auxiliary/external_module_reference.rs b/crates/rome_js_formatter/src/ts/auxiliary/external_module_reference.rs index 4d36f413c3a..8d8343727a2 100644 --- a/crates/rome_js_formatter/src/ts/auxiliary/external_module_reference.rs +++ b/crates/rome_js_formatter/src/ts/auxiliary/external_module_reference.rs @@ -5,7 +5,7 @@ use rome_js_syntax::TsExternalModuleReference; use rome_js_syntax::TsExternalModuleReferenceFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsExternalModuleReference, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsExternalModuleReference, f: &mut JsFormatter) -> FormatResult<()> { let TsExternalModuleReferenceFields { require_token, l_paren_token, diff --git a/crates/rome_js_formatter/src/ts/auxiliary/getter_signature_type_member.rs b/crates/rome_js_formatter/src/ts/auxiliary/getter_signature_type_member.rs index 9ef5a4cd880..2fbfa0e66a6 100644 --- a/crates/rome_js_formatter/src/ts/auxiliary/getter_signature_type_member.rs +++ b/crates/rome_js_formatter/src/ts/auxiliary/getter_signature_type_member.rs @@ -5,7 +5,7 @@ use rome_formatter::write; use rome_js_syntax::{TsGetterSignatureTypeMember, TsGetterSignatureTypeMemberFields}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsGetterSignatureTypeMember, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsGetterSignatureTypeMember, f: &mut JsFormatter) -> FormatResult<()> { let TsGetterSignatureTypeMemberFields { get_token, name, diff --git a/crates/rome_js_formatter/src/ts/auxiliary/implements_clause.rs b/crates/rome_js_formatter/src/ts/auxiliary/implements_clause.rs index 668cfdf8673..67030686468 100644 --- a/crates/rome_js_formatter/src/ts/auxiliary/implements_clause.rs +++ b/crates/rome_js_formatter/src/ts/auxiliary/implements_clause.rs @@ -5,7 +5,7 @@ use rome_js_syntax::TsImplementsClause; use rome_js_syntax::TsImplementsClauseFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsImplementsClause, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsImplementsClause, f: &mut JsFormatter) -> FormatResult<()> { let TsImplementsClauseFields { implements_token, types, @@ -16,13 +16,13 @@ impl FormatNodeFields for FormatNodeRule write!( f, - [group_elements(format_args![ - if_group_breaks(block_indent(format_args![ + [group_elements(&format_args![ + if_group_breaks(&block_indent(&format_args![ &implements_token, space_token(), soft_block_indent(&types) ])), - if_group_fits_on_line(format_args![&implements_token, space_token(), &types]), + if_group_fits_on_line(&format_args![&implements_token, space_token(), &types]), ])] ) } diff --git a/crates/rome_js_formatter/src/ts/auxiliary/index_signature_type_member.rs b/crates/rome_js_formatter/src/ts/auxiliary/index_signature_type_member.rs index 1913f3c9478..1d9eb69b599 100644 --- a/crates/rome_js_formatter/src/ts/auxiliary/index_signature_type_member.rs +++ b/crates/rome_js_formatter/src/ts/auxiliary/index_signature_type_member.rs @@ -5,7 +5,7 @@ use rome_formatter::write; use rome_js_syntax::{TsIndexSignatureTypeMember, TsIndexSignatureTypeMemberFields}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsIndexSignatureTypeMember, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsIndexSignatureTypeMember, f: &mut JsFormatter) -> FormatResult<()> { let TsIndexSignatureTypeMemberFields { readonly_token, l_brack_token, diff --git a/crates/rome_js_formatter/src/ts/auxiliary/mapped_type_as_clause.rs b/crates/rome_js_formatter/src/ts/auxiliary/mapped_type_as_clause.rs index 1e4d8746c8d..2ab816231a5 100644 --- a/crates/rome_js_formatter/src/ts/auxiliary/mapped_type_as_clause.rs +++ b/crates/rome_js_formatter/src/ts/auxiliary/mapped_type_as_clause.rs @@ -4,7 +4,7 @@ use rome_formatter::write; use rome_js_syntax::{TsMappedTypeAsClause, TsMappedTypeAsClauseFields}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsMappedTypeAsClause, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsMappedTypeAsClause, f: &mut JsFormatter) -> FormatResult<()> { let TsMappedTypeAsClauseFields { as_token, ty } = node.as_fields(); write![f, [as_token.format(), space_token(), ty.format()]] diff --git a/crates/rome_js_formatter/src/ts/auxiliary/mapped_type_optional_modifier_clause.rs b/crates/rome_js_formatter/src/ts/auxiliary/mapped_type_optional_modifier_clause.rs index 60c9b2d85d8..90b1e85ea2e 100644 --- a/crates/rome_js_formatter/src/ts/auxiliary/mapped_type_optional_modifier_clause.rs +++ b/crates/rome_js_formatter/src/ts/auxiliary/mapped_type_optional_modifier_clause.rs @@ -7,7 +7,7 @@ use rome_js_syntax::TsMappedTypeOptionalModifierClauseFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields( + fn fmt_fields( node: &TsMappedTypeOptionalModifierClause, f: &mut JsFormatter, ) -> FormatResult<()> { diff --git a/crates/rome_js_formatter/src/ts/auxiliary/mapped_type_readonly_modifier_clause.rs b/crates/rome_js_formatter/src/ts/auxiliary/mapped_type_readonly_modifier_clause.rs index 7b4a480dc2b..0083d1b55f5 100644 --- a/crates/rome_js_formatter/src/ts/auxiliary/mapped_type_readonly_modifier_clause.rs +++ b/crates/rome_js_formatter/src/ts/auxiliary/mapped_type_readonly_modifier_clause.rs @@ -7,7 +7,7 @@ use rome_js_syntax::TsMappedTypeReadonlyModifierClauseFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields( + fn fmt_fields( node: &TsMappedTypeReadonlyModifierClause, f: &mut JsFormatter, ) -> FormatResult<()> { diff --git a/crates/rome_js_formatter/src/ts/auxiliary/method_signature_type_member.rs b/crates/rome_js_formatter/src/ts/auxiliary/method_signature_type_member.rs index 4f7db8eae47..947f2912e5e 100644 --- a/crates/rome_js_formatter/src/ts/auxiliary/method_signature_type_member.rs +++ b/crates/rome_js_formatter/src/ts/auxiliary/method_signature_type_member.rs @@ -5,7 +5,7 @@ use rome_formatter::write; use rome_js_syntax::{TsMethodSignatureTypeMember, TsMethodSignatureTypeMemberFields}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsMethodSignatureTypeMember, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsMethodSignatureTypeMember, f: &mut JsFormatter) -> FormatResult<()> { let TsMethodSignatureTypeMemberFields { name, optional_token, diff --git a/crates/rome_js_formatter/src/ts/auxiliary/module_block.rs b/crates/rome_js_formatter/src/ts/auxiliary/module_block.rs index 594d9dc008c..866375dc68f 100644 --- a/crates/rome_js_formatter/src/ts/auxiliary/module_block.rs +++ b/crates/rome_js_formatter/src/ts/auxiliary/module_block.rs @@ -5,7 +5,7 @@ use rome_js_syntax::TsModuleBlock; use rome_js_syntax::TsModuleBlockFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsModuleBlock, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsModuleBlock, f: &mut JsFormatter) -> FormatResult<()> { let TsModuleBlockFields { l_curly_token, items, diff --git a/crates/rome_js_formatter/src/ts/auxiliary/named_tuple_type_element.rs b/crates/rome_js_formatter/src/ts/auxiliary/named_tuple_type_element.rs index 1c1c26389d2..1adb2bc41d7 100644 --- a/crates/rome_js_formatter/src/ts/auxiliary/named_tuple_type_element.rs +++ b/crates/rome_js_formatter/src/ts/auxiliary/named_tuple_type_element.rs @@ -4,7 +4,7 @@ use rome_formatter::write; use rome_js_syntax::{TsNamedTupleTypeElement, TsNamedTupleTypeElementFields}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsNamedTupleTypeElement, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsNamedTupleTypeElement, f: &mut JsFormatter) -> FormatResult<()> { let TsNamedTupleTypeElementFields { ty, question_mark_token, diff --git a/crates/rome_js_formatter/src/ts/auxiliary/optional_property_annotation.rs b/crates/rome_js_formatter/src/ts/auxiliary/optional_property_annotation.rs index ebea1883211..50d2e52b970 100644 --- a/crates/rome_js_formatter/src/ts/auxiliary/optional_property_annotation.rs +++ b/crates/rome_js_formatter/src/ts/auxiliary/optional_property_annotation.rs @@ -7,7 +7,7 @@ use rome_js_syntax::TsOptionalPropertyAnnotationFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsOptionalPropertyAnnotation, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsOptionalPropertyAnnotation, f: &mut JsFormatter) -> FormatResult<()> { let TsOptionalPropertyAnnotationFields { question_mark_token, type_annotation, diff --git a/crates/rome_js_formatter/src/ts/auxiliary/optional_tuple_type_element.rs b/crates/rome_js_formatter/src/ts/auxiliary/optional_tuple_type_element.rs index c59cb14f354..950f37d412a 100644 --- a/crates/rome_js_formatter/src/ts/auxiliary/optional_tuple_type_element.rs +++ b/crates/rome_js_formatter/src/ts/auxiliary/optional_tuple_type_element.rs @@ -4,7 +4,7 @@ use rome_formatter::write; use rome_js_syntax::{TsOptionalTupleTypeElement, TsOptionalTupleTypeElementFields}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsOptionalTupleTypeElement, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsOptionalTupleTypeElement, f: &mut JsFormatter) -> FormatResult<()> { let TsOptionalTupleTypeElementFields { ty, question_mark_token, diff --git a/crates/rome_js_formatter/src/ts/auxiliary/override_modifier.rs b/crates/rome_js_formatter/src/ts/auxiliary/override_modifier.rs index c248859ad25..f9680060d91 100644 --- a/crates/rome_js_formatter/src/ts/auxiliary/override_modifier.rs +++ b/crates/rome_js_formatter/src/ts/auxiliary/override_modifier.rs @@ -5,7 +5,7 @@ use rome_js_syntax::TsOverrideModifier; use rome_js_syntax::TsOverrideModifierFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsOverrideModifier, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsOverrideModifier, f: &mut JsFormatter) -> FormatResult<()> { let TsOverrideModifierFields { modifier_token } = node.as_fields(); write![f, [modifier_token.format()]] } diff --git a/crates/rome_js_formatter/src/ts/auxiliary/property_signature_type_member.rs b/crates/rome_js_formatter/src/ts/auxiliary/property_signature_type_member.rs index 1b198d6d97a..f60dc9f3e45 100644 --- a/crates/rome_js_formatter/src/ts/auxiliary/property_signature_type_member.rs +++ b/crates/rome_js_formatter/src/ts/auxiliary/property_signature_type_member.rs @@ -1,5 +1,5 @@ use crate::prelude::*; -use crate::utils::FormatTypeMemberSeparator; +use crate::utils::{FormatMemberName, FormatTypeMemberSeparator}; use crate::FormatNodeFields; use rome_formatter::write; use rome_js_syntax::{TsPropertySignatureTypeMember, TsPropertySignatureTypeMemberFields}; @@ -7,10 +7,7 @@ use rome_js_syntax::{TsPropertySignatureTypeMember, TsPropertySignatureTypeMembe impl FormatNodeFields for FormatNodeRule { - fn format_fields( - node: &TsPropertySignatureTypeMember, - f: &mut JsFormatter, - ) -> FormatResult<()> { + fn fmt_fields(node: &TsPropertySignatureTypeMember, f: &mut JsFormatter) -> FormatResult<()> { let TsPropertySignatureTypeMemberFields { readonly_token, name, @@ -24,7 +21,7 @@ impl FormatNodeFields [ readonly_token.format(), space_token(), - name.format(), + FormatMemberName::from(name?), optional_token.format(), type_annotation.format(), FormatTypeMemberSeparator::new(separator_token.as_ref()) diff --git a/crates/rome_js_formatter/src/ts/auxiliary/qualified_module_name.rs b/crates/rome_js_formatter/src/ts/auxiliary/qualified_module_name.rs index 40e8da6c13f..14f3520f291 100644 --- a/crates/rome_js_formatter/src/ts/auxiliary/qualified_module_name.rs +++ b/crates/rome_js_formatter/src/ts/auxiliary/qualified_module_name.rs @@ -5,7 +5,7 @@ use rome_js_syntax::TsQualifiedModuleName; use rome_js_syntax::TsQualifiedModuleNameFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsQualifiedModuleName, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsQualifiedModuleName, f: &mut JsFormatter) -> FormatResult<()> { let TsQualifiedModuleNameFields { left, dot_token, diff --git a/crates/rome_js_formatter/src/ts/auxiliary/qualified_name.rs b/crates/rome_js_formatter/src/ts/auxiliary/qualified_name.rs index 7619e8ab794..2d162ec1e79 100644 --- a/crates/rome_js_formatter/src/ts/auxiliary/qualified_name.rs +++ b/crates/rome_js_formatter/src/ts/auxiliary/qualified_name.rs @@ -5,7 +5,7 @@ use rome_js_syntax::TsQualifiedName; use rome_js_syntax::TsQualifiedNameFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsQualifiedName, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsQualifiedName, f: &mut JsFormatter) -> FormatResult<()> { let TsQualifiedNameFields { left, dot_token, diff --git a/crates/rome_js_formatter/src/ts/auxiliary/readonly_modifier.rs b/crates/rome_js_formatter/src/ts/auxiliary/readonly_modifier.rs index 666800e9d67..c2b58013bc8 100644 --- a/crates/rome_js_formatter/src/ts/auxiliary/readonly_modifier.rs +++ b/crates/rome_js_formatter/src/ts/auxiliary/readonly_modifier.rs @@ -5,7 +5,7 @@ use rome_js_syntax::TsReadonlyModifier; use rome_js_syntax::TsReadonlyModifierFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsReadonlyModifier, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsReadonlyModifier, f: &mut JsFormatter) -> FormatResult<()> { let TsReadonlyModifierFields { modifier_token } = node.as_fields(); write![f, [modifier_token.format()]] } diff --git a/crates/rome_js_formatter/src/ts/auxiliary/rest_tuple_type_element.rs b/crates/rome_js_formatter/src/ts/auxiliary/rest_tuple_type_element.rs index 29bb0ebd44f..16b32da779d 100644 --- a/crates/rome_js_formatter/src/ts/auxiliary/rest_tuple_type_element.rs +++ b/crates/rome_js_formatter/src/ts/auxiliary/rest_tuple_type_element.rs @@ -4,7 +4,7 @@ use rome_formatter::write; use rome_js_syntax::{TsRestTupleTypeElement, TsRestTupleTypeElementFields}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsRestTupleTypeElement, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsRestTupleTypeElement, f: &mut JsFormatter) -> FormatResult<()> { let TsRestTupleTypeElementFields { dotdotdot_token, ty, diff --git a/crates/rome_js_formatter/src/ts/auxiliary/return_type_annotation.rs b/crates/rome_js_formatter/src/ts/auxiliary/return_type_annotation.rs index 3a422d89901..80a8b141b83 100644 --- a/crates/rome_js_formatter/src/ts/auxiliary/return_type_annotation.rs +++ b/crates/rome_js_formatter/src/ts/auxiliary/return_type_annotation.rs @@ -5,7 +5,7 @@ use rome_js_syntax::TsReturnTypeAnnotation; use rome_js_syntax::TsReturnTypeAnnotationFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsReturnTypeAnnotation, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsReturnTypeAnnotation, f: &mut JsFormatter) -> FormatResult<()> { let TsReturnTypeAnnotationFields { colon_token, ty } = node.as_fields(); write![f, [colon_token.format(), space_token(), ty.format()]] } diff --git a/crates/rome_js_formatter/src/ts/auxiliary/setter_signature_type_member.rs b/crates/rome_js_formatter/src/ts/auxiliary/setter_signature_type_member.rs index e154d6647c5..f873d608fc6 100644 --- a/crates/rome_js_formatter/src/ts/auxiliary/setter_signature_type_member.rs +++ b/crates/rome_js_formatter/src/ts/auxiliary/setter_signature_type_member.rs @@ -5,7 +5,7 @@ use rome_formatter::write; use rome_js_syntax::{TsSetterSignatureTypeMember, TsSetterSignatureTypeMemberFields}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsSetterSignatureTypeMember, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsSetterSignatureTypeMember, f: &mut JsFormatter) -> FormatResult<()> { let TsSetterSignatureTypeMemberFields { set_token, name, diff --git a/crates/rome_js_formatter/src/ts/auxiliary/type_annotation.rs b/crates/rome_js_formatter/src/ts/auxiliary/type_annotation.rs index 1c6a9dfef80..d9b2e0ccc6d 100644 --- a/crates/rome_js_formatter/src/ts/auxiliary/type_annotation.rs +++ b/crates/rome_js_formatter/src/ts/auxiliary/type_annotation.rs @@ -4,7 +4,7 @@ use rome_formatter::write; use rome_js_syntax::{TsTypeAnnotation, TsTypeAnnotationFields}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsTypeAnnotation, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsTypeAnnotation, f: &mut JsFormatter) -> FormatResult<()> { let TsTypeAnnotationFields { colon_token, ty } = node.as_fields(); let colon = colon_token.format(); let ty = ty.format(); diff --git a/crates/rome_js_formatter/src/ts/auxiliary/type_constraint_clause.rs b/crates/rome_js_formatter/src/ts/auxiliary/type_constraint_clause.rs index 150c9680df5..debc18cd33c 100644 --- a/crates/rome_js_formatter/src/ts/auxiliary/type_constraint_clause.rs +++ b/crates/rome_js_formatter/src/ts/auxiliary/type_constraint_clause.rs @@ -4,7 +4,7 @@ use rome_formatter::write; use rome_js_syntax::{TsTypeConstraintClause, TsTypeConstraintClauseFields}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsTypeConstraintClause, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsTypeConstraintClause, f: &mut JsFormatter) -> FormatResult<()> { let TsTypeConstraintClauseFields { extends_token, ty } = node.as_fields(); let extends = extends_token.format(); diff --git a/crates/rome_js_formatter/src/ts/auxiliary/type_parameter_name.rs b/crates/rome_js_formatter/src/ts/auxiliary/type_parameter_name.rs index 6216b3e1985..70b9e8d26b9 100644 --- a/crates/rome_js_formatter/src/ts/auxiliary/type_parameter_name.rs +++ b/crates/rome_js_formatter/src/ts/auxiliary/type_parameter_name.rs @@ -4,7 +4,7 @@ use rome_formatter::write; use rome_js_syntax::{TsTypeParameterName, TsTypeParameterNameFields}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsTypeParameterName, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsTypeParameterName, f: &mut JsFormatter) -> FormatResult<()> { let TsTypeParameterNameFields { ident_token } = node.as_fields(); write![f, [ident_token.format()]] diff --git a/crates/rome_js_formatter/src/ts/bindings/identifier_binding.rs b/crates/rome_js_formatter/src/ts/bindings/identifier_binding.rs index e156141f1c6..50b11d3e9f5 100644 --- a/crates/rome_js_formatter/src/ts/bindings/identifier_binding.rs +++ b/crates/rome_js_formatter/src/ts/bindings/identifier_binding.rs @@ -4,7 +4,7 @@ use rome_formatter::write; use rome_js_syntax::{TsIdentifierBinding, TsIdentifierBindingFields}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsIdentifierBinding, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsIdentifierBinding, f: &mut JsFormatter) -> FormatResult<()> { let TsIdentifierBindingFields { name_token } = node.as_fields(); write![f, [name_token.format()]] diff --git a/crates/rome_js_formatter/src/ts/bindings/index_signature_parameter.rs b/crates/rome_js_formatter/src/ts/bindings/index_signature_parameter.rs index 86c94990ff6..06fef99accf 100644 --- a/crates/rome_js_formatter/src/ts/bindings/index_signature_parameter.rs +++ b/crates/rome_js_formatter/src/ts/bindings/index_signature_parameter.rs @@ -4,7 +4,7 @@ use rome_formatter::write; use rome_js_syntax::{TsIndexSignatureParameter, TsIndexSignatureParameterFields}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsIndexSignatureParameter, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsIndexSignatureParameter, f: &mut JsFormatter) -> FormatResult<()> { let TsIndexSignatureParameterFields { binding, type_annotation, diff --git a/crates/rome_js_formatter/src/ts/bindings/property_parameter.rs b/crates/rome_js_formatter/src/ts/bindings/property_parameter.rs index 2ad7ba85234..4e47bcd3df9 100644 --- a/crates/rome_js_formatter/src/ts/bindings/property_parameter.rs +++ b/crates/rome_js_formatter/src/ts/bindings/property_parameter.rs @@ -4,7 +4,7 @@ use rome_formatter::write; use rome_js_syntax::{TsPropertyParameter, TsPropertyParameterFields}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsPropertyParameter, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsPropertyParameter, f: &mut JsFormatter) -> FormatResult<()> { let TsPropertyParameterFields { modifiers, formal_parameter, diff --git a/crates/rome_js_formatter/src/ts/bindings/this_parameter.rs b/crates/rome_js_formatter/src/ts/bindings/this_parameter.rs index 21be0f13c7d..da171c6a89f 100644 --- a/crates/rome_js_formatter/src/ts/bindings/this_parameter.rs +++ b/crates/rome_js_formatter/src/ts/bindings/this_parameter.rs @@ -4,7 +4,7 @@ use rome_formatter::write; use rome_js_syntax::{TsThisParameter, TsThisParameterFields}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsThisParameter, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsThisParameter, f: &mut JsFormatter) -> FormatResult<()> { let TsThisParameterFields { this_token, type_annotation, diff --git a/crates/rome_js_formatter/src/ts/bindings/type_parameter.rs b/crates/rome_js_formatter/src/ts/bindings/type_parameter.rs index d9333b91f60..ecd81cc4499 100644 --- a/crates/rome_js_formatter/src/ts/bindings/type_parameter.rs +++ b/crates/rome_js_formatter/src/ts/bindings/type_parameter.rs @@ -4,7 +4,7 @@ use rome_formatter::write; use rome_js_syntax::{TsTypeParameter, TsTypeParameterFields}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsTypeParameter, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsTypeParameter, f: &mut JsFormatter) -> FormatResult<()> { let TsTypeParameterFields { name, constraint, diff --git a/crates/rome_js_formatter/src/ts/bindings/type_parameters.rs b/crates/rome_js_formatter/src/ts/bindings/type_parameters.rs index b469df74ea8..e36b1f1dd74 100644 --- a/crates/rome_js_formatter/src/ts/bindings/type_parameters.rs +++ b/crates/rome_js_formatter/src/ts/bindings/type_parameters.rs @@ -4,7 +4,7 @@ use rome_formatter::write; use rome_js_syntax::{TsTypeParameters, TsTypeParametersFields}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsTypeParameters, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsTypeParameters, f: &mut JsFormatter) -> FormatResult<()> { let TsTypeParametersFields { items, r_angle_token, diff --git a/crates/rome_js_formatter/src/ts/classes/constructor_signature_class_member.rs b/crates/rome_js_formatter/src/ts/classes/constructor_signature_class_member.rs index 3616047df2b..303ce39d69c 100644 --- a/crates/rome_js_formatter/src/ts/classes/constructor_signature_class_member.rs +++ b/crates/rome_js_formatter/src/ts/classes/constructor_signature_class_member.rs @@ -8,7 +8,7 @@ use rome_js_syntax::TsConstructorSignatureClassMemberFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields( + fn fmt_fields( node: &TsConstructorSignatureClassMember, f: &mut JsFormatter, ) -> FormatResult<()> { diff --git a/crates/rome_js_formatter/src/ts/classes/extends_clause.rs b/crates/rome_js_formatter/src/ts/classes/extends_clause.rs index c37a0426dc4..1b4375ddd00 100644 --- a/crates/rome_js_formatter/src/ts/classes/extends_clause.rs +++ b/crates/rome_js_formatter/src/ts/classes/extends_clause.rs @@ -4,7 +4,7 @@ use rome_formatter::{format_args, write}; use rome_js_syntax::{TsExtendsClause, TsExtendsClauseFields}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsExtendsClause, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsExtendsClause, f: &mut JsFormatter) -> FormatResult<()> { let TsExtendsClauseFields { extends_token, types, @@ -15,13 +15,13 @@ impl FormatNodeFields for FormatNodeRule { write!( f, - [group_elements(format_args!( - if_group_breaks(block_indent(format_args![ + [group_elements(&format_args!( + if_group_breaks(&block_indent(&format_args![ &extends_token, space_token(), soft_block_indent(&types) ])), - if_group_fits_on_line(format_args![&extends_token, space_token(), &types]), + if_group_fits_on_line(&format_args![&extends_token, space_token(), &types]), ))] ) } diff --git a/crates/rome_js_formatter/src/ts/classes/getter_signature_class_member.rs b/crates/rome_js_formatter/src/ts/classes/getter_signature_class_member.rs index ddffefa4b37..87aab4232ba 100644 --- a/crates/rome_js_formatter/src/ts/classes/getter_signature_class_member.rs +++ b/crates/rome_js_formatter/src/ts/classes/getter_signature_class_member.rs @@ -8,7 +8,7 @@ use rome_js_syntax::{TsGetterSignatureClassMember, TsGetterSignatureClassMemberF impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsGetterSignatureClassMember, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsGetterSignatureClassMember, f: &mut JsFormatter) -> FormatResult<()> { let TsGetterSignatureClassMemberFields { modifiers, get_token, diff --git a/crates/rome_js_formatter/src/ts/classes/index_signature_class_member.rs b/crates/rome_js_formatter/src/ts/classes/index_signature_class_member.rs index 65461a01a88..9600ecdabc5 100644 --- a/crates/rome_js_formatter/src/ts/classes/index_signature_class_member.rs +++ b/crates/rome_js_formatter/src/ts/classes/index_signature_class_member.rs @@ -6,7 +6,7 @@ use rome_js_syntax::TsIndexSignatureClassMember; use rome_js_syntax::TsIndexSignatureClassMemberFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsIndexSignatureClassMember, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsIndexSignatureClassMember, f: &mut JsFormatter) -> FormatResult<()> { let TsIndexSignatureClassMemberFields { modifiers, l_brack_token, diff --git a/crates/rome_js_formatter/src/ts/classes/method_signature_class_member.rs b/crates/rome_js_formatter/src/ts/classes/method_signature_class_member.rs index 5c2e01147ce..19b533a170c 100644 --- a/crates/rome_js_formatter/src/ts/classes/method_signature_class_member.rs +++ b/crates/rome_js_formatter/src/ts/classes/method_signature_class_member.rs @@ -1,5 +1,5 @@ use crate::prelude::*; -use crate::utils::FormatWithSemicolon; +use crate::utils::{FormatMemberName, FormatWithSemicolon}; use crate::FormatNodeFields; use rome_formatter::{format_args, write}; use rome_js_syntax::{TsMethodSignatureClassMember, TsMethodSignatureClassMemberFields}; @@ -7,7 +7,7 @@ use rome_js_syntax::{TsMethodSignatureClassMember, TsMethodSignatureClassMemberF impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsMethodSignatureClassMember, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsMethodSignatureClassMember, f: &mut JsFormatter) -> FormatResult<()> { let TsMethodSignatureClassMemberFields { modifiers, async_token, @@ -28,7 +28,7 @@ impl FormatNodeFields .format() .with_or_empty(|token, f| write![f, [token, space_token()]]), space_token(), - name.format(), + FormatMemberName::from(name?), question_mark_token.format(), type_parameters.format(), parameters.format(), diff --git a/crates/rome_js_formatter/src/ts/classes/property_signature_class_member.rs b/crates/rome_js_formatter/src/ts/classes/property_signature_class_member.rs index bfe13fee821..0bdbc620a07 100644 --- a/crates/rome_js_formatter/src/ts/classes/property_signature_class_member.rs +++ b/crates/rome_js_formatter/src/ts/classes/property_signature_class_member.rs @@ -8,10 +8,7 @@ use rome_js_syntax::{TsPropertySignatureClassMember, TsPropertySignatureClassMem impl FormatNodeFields for FormatNodeRule { - fn format_fields( - node: &TsPropertySignatureClassMember, - f: &mut JsFormatter, - ) -> FormatResult<()> { + fn fmt_fields(node: &TsPropertySignatureClassMember, f: &mut JsFormatter) -> FormatResult<()> { let TsPropertySignatureClassMemberFields { modifiers, name, diff --git a/crates/rome_js_formatter/src/ts/classes/setter_signature_class_member.rs b/crates/rome_js_formatter/src/ts/classes/setter_signature_class_member.rs index 78015015fd1..f9b6f860845 100644 --- a/crates/rome_js_formatter/src/ts/classes/setter_signature_class_member.rs +++ b/crates/rome_js_formatter/src/ts/classes/setter_signature_class_member.rs @@ -7,7 +7,7 @@ use rome_js_syntax::{TsSetterSignatureClassMember, TsSetterSignatureClassMemberF impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsSetterSignatureClassMember, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsSetterSignatureClassMember, f: &mut JsFormatter) -> FormatResult<()> { let TsSetterSignatureClassMemberFields { modifiers, set_token, diff --git a/crates/rome_js_formatter/src/ts/declarations/declare_function_declaration.rs b/crates/rome_js_formatter/src/ts/declarations/declare_function_declaration.rs index 22d66b51999..cc5178d2356 100644 --- a/crates/rome_js_formatter/src/ts/declarations/declare_function_declaration.rs +++ b/crates/rome_js_formatter/src/ts/declarations/declare_function_declaration.rs @@ -8,7 +8,7 @@ use rome_js_syntax::TsDeclareFunctionDeclarationFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsDeclareFunctionDeclaration, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsDeclareFunctionDeclaration, f: &mut JsFormatter) -> FormatResult<()> { let TsDeclareFunctionDeclarationFields { async_token, function_token, diff --git a/crates/rome_js_formatter/src/ts/declarations/enum_declaration.rs b/crates/rome_js_formatter/src/ts/declarations/enum_declaration.rs index 9ef02854b51..e20a7bf95ef 100644 --- a/crates/rome_js_formatter/src/ts/declarations/enum_declaration.rs +++ b/crates/rome_js_formatter/src/ts/declarations/enum_declaration.rs @@ -7,7 +7,7 @@ use rome_js_syntax::{TsEnumDeclaration, TsEnumDeclarationFields}; use rome_rowan::AstNode; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsEnumDeclaration, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsEnumDeclaration, f: &mut JsFormatter) -> FormatResult<()> { let TsEnumDeclarationFields { const_token, enum_token, @@ -34,7 +34,7 @@ impl FormatNodeFields for FormatNodeRule { let has_newline = has_leading_newline(members.syntax()); let members = format_with(|f| { - f.join_with(if has_newline { + f.join_with(&if has_newline { hard_line_break() } else { soft_line_break_or_space() diff --git a/crates/rome_js_formatter/src/ts/declarations/external_module_declaration.rs b/crates/rome_js_formatter/src/ts/declarations/external_module_declaration.rs index c6f3a3762ad..b4bfb04f311 100644 --- a/crates/rome_js_formatter/src/ts/declarations/external_module_declaration.rs +++ b/crates/rome_js_formatter/src/ts/declarations/external_module_declaration.rs @@ -6,7 +6,7 @@ use rome_js_syntax::TsExternalModuleDeclaration; use rome_js_syntax::TsExternalModuleDeclarationFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsExternalModuleDeclaration, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsExternalModuleDeclaration, f: &mut JsFormatter) -> FormatResult<()> { let TsExternalModuleDeclarationFields { body, module_token, diff --git a/crates/rome_js_formatter/src/ts/declarations/global_declaration.rs b/crates/rome_js_formatter/src/ts/declarations/global_declaration.rs index 853ed038a2d..a898dda17f5 100644 --- a/crates/rome_js_formatter/src/ts/declarations/global_declaration.rs +++ b/crates/rome_js_formatter/src/ts/declarations/global_declaration.rs @@ -6,7 +6,7 @@ use rome_js_syntax::TsGlobalDeclaration; use rome_js_syntax::TsGlobalDeclarationFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsGlobalDeclaration, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsGlobalDeclaration, f: &mut JsFormatter) -> FormatResult<()> { let TsGlobalDeclarationFields { global_token, body } = node.as_fields(); write![f, [global_token.format(), space_token(), body.format()]] diff --git a/crates/rome_js_formatter/src/ts/declarations/import_equals_declaration.rs b/crates/rome_js_formatter/src/ts/declarations/import_equals_declaration.rs index 80d9ea7b5f1..f6430612804 100644 --- a/crates/rome_js_formatter/src/ts/declarations/import_equals_declaration.rs +++ b/crates/rome_js_formatter/src/ts/declarations/import_equals_declaration.rs @@ -6,7 +6,7 @@ use rome_js_syntax::TsImportEqualsDeclaration; use rome_js_syntax::TsImportEqualsDeclarationFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsImportEqualsDeclaration, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsImportEqualsDeclaration, f: &mut JsFormatter) -> FormatResult<()> { let TsImportEqualsDeclarationFields { import_token, type_token, diff --git a/crates/rome_js_formatter/src/ts/declarations/interface_declaration.rs b/crates/rome_js_formatter/src/ts/declarations/interface_declaration.rs index 549753ba998..05235a4da42 100644 --- a/crates/rome_js_formatter/src/ts/declarations/interface_declaration.rs +++ b/crates/rome_js_formatter/src/ts/declarations/interface_declaration.rs @@ -5,7 +5,7 @@ use rome_formatter::write; use rome_js_syntax::{TsInterfaceDeclaration, TsInterfaceDeclarationFields}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsInterfaceDeclaration, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsInterfaceDeclaration, f: &mut JsFormatter) -> FormatResult<()> { let TsInterfaceDeclarationFields { interface_token, id, diff --git a/crates/rome_js_formatter/src/ts/declarations/module_declaration.rs b/crates/rome_js_formatter/src/ts/declarations/module_declaration.rs index 3f46243742f..c3c79d20764 100644 --- a/crates/rome_js_formatter/src/ts/declarations/module_declaration.rs +++ b/crates/rome_js_formatter/src/ts/declarations/module_declaration.rs @@ -5,7 +5,7 @@ use rome_js_syntax::TsModuleDeclaration; use rome_js_syntax::TsModuleDeclarationFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsModuleDeclaration, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsModuleDeclaration, f: &mut JsFormatter) -> FormatResult<()> { let TsModuleDeclarationFields { module_or_namespace, name, diff --git a/crates/rome_js_formatter/src/ts/declarations/type_alias_declaration.rs b/crates/rome_js_formatter/src/ts/declarations/type_alias_declaration.rs index 8beb7278433..e0566175a66 100644 --- a/crates/rome_js_formatter/src/ts/declarations/type_alias_declaration.rs +++ b/crates/rome_js_formatter/src/ts/declarations/type_alias_declaration.rs @@ -5,7 +5,7 @@ use rome_formatter::{format_args, write}; use rome_js_syntax::{TsTypeAliasDeclaration, TsTypeAliasDeclarationFields}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsTypeAliasDeclaration, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsTypeAliasDeclaration, f: &mut JsFormatter) -> FormatResult<()> { let TsTypeAliasDeclarationFields { type_token, binding_identifier, diff --git a/crates/rome_js_formatter/src/ts/expressions/as_expression.rs b/crates/rome_js_formatter/src/ts/expressions/as_expression.rs index 33ae4e17496..960033e5fed 100644 --- a/crates/rome_js_formatter/src/ts/expressions/as_expression.rs +++ b/crates/rome_js_formatter/src/ts/expressions/as_expression.rs @@ -5,7 +5,7 @@ use rome_js_syntax::TsAsExpression; use rome_js_syntax::TsAsExpressionFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsAsExpression, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsAsExpression, f: &mut JsFormatter) -> FormatResult<()> { let TsAsExpressionFields { ty, as_token, diff --git a/crates/rome_js_formatter/src/ts/expressions/name_with_type_arguments.rs b/crates/rome_js_formatter/src/ts/expressions/name_with_type_arguments.rs index 46465b2e885..79fffbb7614 100644 --- a/crates/rome_js_formatter/src/ts/expressions/name_with_type_arguments.rs +++ b/crates/rome_js_formatter/src/ts/expressions/name_with_type_arguments.rs @@ -4,7 +4,7 @@ use rome_formatter::write; use rome_js_syntax::{TsNameWithTypeArguments, TsNameWithTypeArgumentsFields}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsNameWithTypeArguments, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsNameWithTypeArguments, f: &mut JsFormatter) -> FormatResult<()> { let TsNameWithTypeArgumentsFields { name, type_arguments, diff --git a/crates/rome_js_formatter/src/ts/expressions/non_null_assertion_expression.rs b/crates/rome_js_formatter/src/ts/expressions/non_null_assertion_expression.rs index 2fbd0bcf967..cede60d891f 100644 --- a/crates/rome_js_formatter/src/ts/expressions/non_null_assertion_expression.rs +++ b/crates/rome_js_formatter/src/ts/expressions/non_null_assertion_expression.rs @@ -7,7 +7,7 @@ use rome_js_syntax::TsNonNullAssertionExpressionFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsNonNullAssertionExpression, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsNonNullAssertionExpression, f: &mut JsFormatter) -> FormatResult<()> { let TsNonNullAssertionExpressionFields { expression, excl_token, diff --git a/crates/rome_js_formatter/src/ts/expressions/template_chunk_element.rs b/crates/rome_js_formatter/src/ts/expressions/template_chunk_element.rs index 5dd935ee72b..13c637290a3 100644 --- a/crates/rome_js_formatter/src/ts/expressions/template_chunk_element.rs +++ b/crates/rome_js_formatter/src/ts/expressions/template_chunk_element.rs @@ -4,10 +4,7 @@ use crate::FormatNodeFields; use rome_js_syntax::{TsTemplateChunkElement, TsTemplateChunkElementFields}; impl FormatNodeFields for FormatNodeRule { - fn format_fields( - node: &TsTemplateChunkElement, - formatter: &mut JsFormatter, - ) -> FormatResult<()> { + fn fmt_fields(node: &TsTemplateChunkElement, formatter: &mut JsFormatter) -> FormatResult<()> { let TsTemplateChunkElementFields { template_chunk_token, } = node.as_fields(); diff --git a/crates/rome_js_formatter/src/ts/expressions/template_element.rs b/crates/rome_js_formatter/src/ts/expressions/template_element.rs index 19e5c30fdd6..cc2aa2f4b8a 100644 --- a/crates/rome_js_formatter/src/ts/expressions/template_element.rs +++ b/crates/rome_js_formatter/src/ts/expressions/template_element.rs @@ -4,7 +4,7 @@ use crate::FormatNodeFields; use rome_js_syntax::TsTemplateElement; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsTemplateElement, formatter: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsTemplateElement, formatter: &mut JsFormatter) -> FormatResult<()> { format_template_literal(TemplateElement::Ts(node.clone()), formatter) } } diff --git a/crates/rome_js_formatter/src/ts/expressions/template_literal_type.rs b/crates/rome_js_formatter/src/ts/expressions/template_literal_type.rs index a7809944c9f..6349fd8753f 100644 --- a/crates/rome_js_formatter/src/ts/expressions/template_literal_type.rs +++ b/crates/rome_js_formatter/src/ts/expressions/template_literal_type.rs @@ -5,7 +5,7 @@ use rome_js_syntax::TsTemplateLiteralType; use rome_js_syntax::TsTemplateLiteralTypeFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsTemplateLiteralType, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsTemplateLiteralType, f: &mut JsFormatter) -> FormatResult<()> { let TsTemplateLiteralTypeFields { l_tick_token, elements, diff --git a/crates/rome_js_formatter/src/ts/expressions/type_arguments.rs b/crates/rome_js_formatter/src/ts/expressions/type_arguments.rs index f54cef085f9..2e9483830c8 100644 --- a/crates/rome_js_formatter/src/ts/expressions/type_arguments.rs +++ b/crates/rome_js_formatter/src/ts/expressions/type_arguments.rs @@ -4,7 +4,7 @@ use rome_formatter::write; use rome_js_syntax::{TsTypeArguments, TsTypeArgumentsFields}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsTypeArguments, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsTypeArguments, f: &mut JsFormatter) -> FormatResult<()> { let TsTypeArgumentsFields { l_angle_token, ts_type_argument_list, diff --git a/crates/rome_js_formatter/src/ts/expressions/type_assertion_expression.rs b/crates/rome_js_formatter/src/ts/expressions/type_assertion_expression.rs index fe0957f7456..4eebaf09bda 100644 --- a/crates/rome_js_formatter/src/ts/expressions/type_assertion_expression.rs +++ b/crates/rome_js_formatter/src/ts/expressions/type_assertion_expression.rs @@ -5,7 +5,7 @@ use rome_js_syntax::TsTypeAssertionExpression; use rome_js_syntax::TsTypeAssertionExpressionFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsTypeAssertionExpression, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsTypeAssertionExpression, f: &mut JsFormatter) -> FormatResult<()> { let TsTypeAssertionExpressionFields { l_angle_token, ty, diff --git a/crates/rome_js_formatter/src/ts/lists/enum_member_list.rs b/crates/rome_js_formatter/src/ts/lists/enum_member_list.rs index f35cac24db0..f61860fdcc7 100644 --- a/crates/rome_js_formatter/src/ts/lists/enum_member_list.rs +++ b/crates/rome_js_formatter/src/ts/lists/enum_member_list.rs @@ -5,8 +5,8 @@ use rome_js_syntax::TsEnumMemberList; impl FormatRule for FormatTsEnumMemberList { type Context = JsFormatContext; - fn format(node: &TsEnumMemberList, f: &mut JsFormatter) -> FormatResult<()> { - f.join_with(soft_line_break_or_space()) + fn fmt(node: &TsEnumMemberList, f: &mut JsFormatter) -> FormatResult<()> { + f.join_with(&soft_line_break_or_space()) .entries(node.format_separated(token(","))) .finish() } diff --git a/crates/rome_js_formatter/src/ts/lists/index_signature_modifier_list.rs b/crates/rome_js_formatter/src/ts/lists/index_signature_modifier_list.rs index f5725ce64c0..5071be57176 100644 --- a/crates/rome_js_formatter/src/ts/lists/index_signature_modifier_list.rs +++ b/crates/rome_js_formatter/src/ts/lists/index_signature_modifier_list.rs @@ -7,8 +7,8 @@ use rome_js_syntax::TsIndexSignatureModifierList; impl FormatRule for FormatTsIndexSignatureModifierList { type Context = JsFormatContext; - fn format(node: &TsIndexSignatureModifierList, f: &mut JsFormatter) -> FormatResult<()> { - f.join_with(space_token()) + fn fmt(node: &TsIndexSignatureModifierList, f: &mut JsFormatter) -> FormatResult<()> { + f.join_with(&space_token()) .entries(sort_modifiers_by_precedence(node).into_iter().formatted()) .finish() } diff --git a/crates/rome_js_formatter/src/ts/lists/intersection_type_element_list.rs b/crates/rome_js_formatter/src/ts/lists/intersection_type_element_list.rs index 6509ecf23d6..14e296f82f9 100644 --- a/crates/rome_js_formatter/src/ts/lists/intersection_type_element_list.rs +++ b/crates/rome_js_formatter/src/ts/lists/intersection_type_element_list.rs @@ -7,7 +7,7 @@ use rome_rowan::AstSeparatedList; impl FormatRule for FormatTsIntersectionTypeElementList { type Context = JsFormatContext; - fn format(node: &TsIntersectionTypeElementList, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &TsIntersectionTypeElementList, f: &mut JsFormatter) -> FormatResult<()> { let last_index = node.len().saturating_sub(1); f.join() diff --git a/crates/rome_js_formatter/src/ts/lists/method_signature_modifier_list.rs b/crates/rome_js_formatter/src/ts/lists/method_signature_modifier_list.rs index ac254676b4d..9afc7a2a12a 100644 --- a/crates/rome_js_formatter/src/ts/lists/method_signature_modifier_list.rs +++ b/crates/rome_js_formatter/src/ts/lists/method_signature_modifier_list.rs @@ -6,8 +6,8 @@ use rome_js_syntax::TsMethodSignatureModifierList; impl FormatRule for FormatTsMethodSignatureModifierList { type Context = JsFormatContext; - fn format(node: &TsMethodSignatureModifierList, f: &mut JsFormatter) -> FormatResult<()> { - f.join_with(space_token()) + fn fmt(node: &TsMethodSignatureModifierList, f: &mut JsFormatter) -> FormatResult<()> { + f.join_with(&space_token()) .entries(sort_modifiers_by_precedence(node).into_iter().formatted()) .finish() } diff --git a/crates/rome_js_formatter/src/ts/lists/property_parameter_modifier_list.rs b/crates/rome_js_formatter/src/ts/lists/property_parameter_modifier_list.rs index ad06d110877..34a5ce7e8a1 100644 --- a/crates/rome_js_formatter/src/ts/lists/property_parameter_modifier_list.rs +++ b/crates/rome_js_formatter/src/ts/lists/property_parameter_modifier_list.rs @@ -6,8 +6,8 @@ use rome_js_syntax::TsPropertyParameterModifierList; impl FormatRule for FormatTsPropertyParameterModifierList { type Context = JsFormatContext; - fn format(node: &TsPropertyParameterModifierList, f: &mut JsFormatter) -> FormatResult<()> { - f.join_with(space_token()) + fn fmt(node: &TsPropertyParameterModifierList, f: &mut JsFormatter) -> FormatResult<()> { + f.join_with(&space_token()) .entries(sort_modifiers_by_precedence(node).into_iter().formatted()) .finish() } diff --git a/crates/rome_js_formatter/src/ts/lists/property_signature_modifier_list.rs b/crates/rome_js_formatter/src/ts/lists/property_signature_modifier_list.rs index f9bbc523587..3bf2d560763 100644 --- a/crates/rome_js_formatter/src/ts/lists/property_signature_modifier_list.rs +++ b/crates/rome_js_formatter/src/ts/lists/property_signature_modifier_list.rs @@ -6,8 +6,8 @@ use rome_js_syntax::TsPropertySignatureModifierList; impl FormatRule for FormatTsPropertySignatureModifierList { type Context = JsFormatContext; - fn format(node: &TsPropertySignatureModifierList, f: &mut JsFormatter) -> FormatResult<()> { - f.join_with(space_token()) + fn fmt(node: &TsPropertySignatureModifierList, f: &mut JsFormatter) -> FormatResult<()> { + f.join_with(&space_token()) .entries(sort_modifiers_by_precedence(node).into_iter().formatted()) .finish() } diff --git a/crates/rome_js_formatter/src/ts/lists/template_element_list.rs b/crates/rome_js_formatter/src/ts/lists/template_element_list.rs index c5639f298be..99dd72b93c0 100644 --- a/crates/rome_js_formatter/src/ts/lists/template_element_list.rs +++ b/crates/rome_js_formatter/src/ts/lists/template_element_list.rs @@ -5,11 +5,11 @@ use rome_js_syntax::TsTemplateElementList; impl FormatRule for FormatTsTemplateElementList { type Context = JsFormatContext; - fn format(node: &TsTemplateElementList, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &TsTemplateElementList, f: &mut JsFormatter) -> FormatResult<()> { let mut join = f.join(); for item in node { - join.entry(&group_elements(item.format())); + join.entry(&group_elements(&item.format())); } join.finish() diff --git a/crates/rome_js_formatter/src/ts/lists/tuple_type_element_list.rs b/crates/rome_js_formatter/src/ts/lists/tuple_type_element_list.rs index f39faf76eef..3c89f38c283 100644 --- a/crates/rome_js_formatter/src/ts/lists/tuple_type_element_list.rs +++ b/crates/rome_js_formatter/src/ts/lists/tuple_type_element_list.rs @@ -5,8 +5,8 @@ use rome_js_syntax::TsTupleTypeElementList; impl FormatRule for FormatTsTupleTypeElementList { type Context = JsFormatContext; - fn format(node: &TsTupleTypeElementList, f: &mut JsFormatter) -> FormatResult<()> { - f.join_with(soft_line_break_or_space()) + fn fmt(node: &TsTupleTypeElementList, f: &mut JsFormatter) -> FormatResult<()> { + f.join_with(&soft_line_break_or_space()) .entries(node.format_separated(token(","))) .finish() } diff --git a/crates/rome_js_formatter/src/ts/lists/type_argument_list.rs b/crates/rome_js_formatter/src/ts/lists/type_argument_list.rs index 374d680dee6..7bca496745a 100644 --- a/crates/rome_js_formatter/src/ts/lists/type_argument_list.rs +++ b/crates/rome_js_formatter/src/ts/lists/type_argument_list.rs @@ -5,8 +5,8 @@ use rome_js_syntax::TsTypeArgumentList; impl FormatRule for FormatTsTypeArgumentList { type Context = JsFormatContext; - fn format(node: &TsTypeArgumentList, f: &mut JsFormatter) -> FormatResult<()> { - f.join_with(soft_line_break_or_space()) + fn fmt(node: &TsTypeArgumentList, f: &mut JsFormatter) -> FormatResult<()> { + f.join_with(&soft_line_break_or_space()) .entries( node.format_separated(token(",")).with_options( FormatSeparatedOptions::default() diff --git a/crates/rome_js_formatter/src/ts/lists/type_list.rs b/crates/rome_js_formatter/src/ts/lists/type_list.rs index 3e177696175..2ca5ca8fec8 100644 --- a/crates/rome_js_formatter/src/ts/lists/type_list.rs +++ b/crates/rome_js_formatter/src/ts/lists/type_list.rs @@ -5,9 +5,9 @@ use rome_js_syntax::TsTypeList; impl FormatRule for FormatTsTypeList { type Context = JsFormatContext; - fn format(node: &TsTypeList, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &TsTypeList, f: &mut JsFormatter) -> FormatResult<()> { // the grouping will be applied by the parent - f.join_with(soft_line_break_or_space()) + f.join_with(&soft_line_break_or_space()) .entries( node.format_separated(token(",")).with_options( FormatSeparatedOptions::default() diff --git a/crates/rome_js_formatter/src/ts/lists/type_member_list.rs b/crates/rome_js_formatter/src/ts/lists/type_member_list.rs index 567f4a412d2..986fe598cc5 100644 --- a/crates/rome_js_formatter/src/ts/lists/type_member_list.rs +++ b/crates/rome_js_formatter/src/ts/lists/type_member_list.rs @@ -8,11 +8,11 @@ use rome_rowan::AstNodeList; impl FormatRule for FormatTsTypeMemberList { type Context = JsFormatContext; - fn format(node: &TsTypeMemberList, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &TsTypeMemberList, f: &mut JsFormatter) -> FormatResult<()> { let items = node.iter(); let last_index = items.len().saturating_sub(1); - f.join_with(soft_line_break_or_space()) + f.join_with(&soft_line_break_or_space()) .entries(items.enumerate().map(|(index, member)| TsTypeMemberItem { last: index == last_index, member, @@ -27,7 +27,7 @@ struct TsTypeMemberItem { } impl Format for TsTypeMemberItem { - fn format(&self, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(&self, f: &mut JsFormatter) -> FormatResult<()> { let mut buffer = VecBuffer::new(f.state_mut()); write!(buffer, [self.member.format()])?; @@ -41,7 +41,7 @@ impl Format for TsTypeMemberItem { write!( f, - [group_elements(format_once(|f| { + [group_elements(&format_once(|f| { f.write_element(formatted_element) }))] )?; @@ -50,7 +50,7 @@ impl Format for TsTypeMemberItem { // Children don't format the separator on purpose, so it's up to the parent - this node, // to decide to print their separator if self.last { - write!(f, [if_group_breaks(token(";"))])?; + write!(f, [if_group_breaks(&token(";"))])?; } else { write!(f, [token(";")])?; } diff --git a/crates/rome_js_formatter/src/ts/lists/type_parameter_list.rs b/crates/rome_js_formatter/src/ts/lists/type_parameter_list.rs index 05e6db4a0ae..35634b85dd9 100644 --- a/crates/rome_js_formatter/src/ts/lists/type_parameter_list.rs +++ b/crates/rome_js_formatter/src/ts/lists/type_parameter_list.rs @@ -6,7 +6,7 @@ use rome_rowan::AstSeparatedList; impl FormatRule for FormatTsTypeParameterList { type Context = JsFormatContext; - fn format(node: &TsTypeParameterList, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &TsTypeParameterList, f: &mut JsFormatter) -> FormatResult<()> { // nodes and formatter are not aware of the source type (TSX vs TS), which means we can't // exactly pin point the exact case. // @@ -19,7 +19,7 @@ impl FormatRule for FormatTsTypeParameterList { TrailingSeparator::default() }; - f.join_with(soft_line_break_or_space()) + f.join_with(&soft_line_break_or_space()) .entries(node.format_separated(token(",")).with_options( FormatSeparatedOptions::default().with_trailing_separator(trailing_separator), )) diff --git a/crates/rome_js_formatter/src/ts/lists/union_type_variant_list.rs b/crates/rome_js_formatter/src/ts/lists/union_type_variant_list.rs index d55e9f124e7..1ffd1a0695b 100644 --- a/crates/rome_js_formatter/src/ts/lists/union_type_variant_list.rs +++ b/crates/rome_js_formatter/src/ts/lists/union_type_variant_list.rs @@ -7,7 +7,7 @@ use rome_rowan::{AstSeparatedElement, AstSeparatedList}; impl FormatRule for FormatTsUnionTypeVariantList { type Context = JsFormatContext; - fn format(node: &TsUnionTypeVariantList, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(node: &TsUnionTypeVariantList, f: &mut JsFormatter) -> FormatResult<()> { let last_index = node.len().saturating_sub(1); f.join() @@ -29,8 +29,8 @@ pub struct FormatTypeVariant { } impl Format for FormatTypeVariant { - fn format(&self, f: &mut JsFormatter) -> FormatResult<()> { - write!(f, [group_elements(self.element.node().format())])?; + fn fmt(&self, f: &mut JsFormatter) -> FormatResult<()> { + write!(f, [group_elements(&self.element.node().format())])?; let separator = self.element.trailing_separator()?; diff --git a/crates/rome_js_formatter/src/ts/module/export_as_namespace_clause.rs b/crates/rome_js_formatter/src/ts/module/export_as_namespace_clause.rs index 735e4408eaa..3b0ecb2ac91 100644 --- a/crates/rome_js_formatter/src/ts/module/export_as_namespace_clause.rs +++ b/crates/rome_js_formatter/src/ts/module/export_as_namespace_clause.rs @@ -6,7 +6,7 @@ use rome_js_syntax::TsExportAsNamespaceClause; use rome_js_syntax::TsExportAsNamespaceClauseFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsExportAsNamespaceClause, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsExportAsNamespaceClause, f: &mut JsFormatter) -> FormatResult<()> { let TsExportAsNamespaceClauseFields { as_token, namespace_token, diff --git a/crates/rome_js_formatter/src/ts/module/export_assignment_clause.rs b/crates/rome_js_formatter/src/ts/module/export_assignment_clause.rs index cd1572c55db..4f3687de600 100644 --- a/crates/rome_js_formatter/src/ts/module/export_assignment_clause.rs +++ b/crates/rome_js_formatter/src/ts/module/export_assignment_clause.rs @@ -6,7 +6,7 @@ use rome_js_syntax::TsExportAssignmentClause; use rome_js_syntax::TsExportAssignmentClauseFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsExportAssignmentClause, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsExportAssignmentClause, f: &mut JsFormatter) -> FormatResult<()> { let TsExportAssignmentClauseFields { eq_token, expression, diff --git a/crates/rome_js_formatter/src/ts/module/export_declare_clause.rs b/crates/rome_js_formatter/src/ts/module/export_declare_clause.rs index 846db764496..eeb6b0ce2ee 100644 --- a/crates/rome_js_formatter/src/ts/module/export_declare_clause.rs +++ b/crates/rome_js_formatter/src/ts/module/export_declare_clause.rs @@ -5,7 +5,7 @@ use rome_js_syntax::TsExportDeclareClause; use rome_js_syntax::TsExportDeclareClauseFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsExportDeclareClause, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsExportDeclareClause, f: &mut JsFormatter) -> FormatResult<()> { let TsExportDeclareClauseFields { declare_token, declaration, diff --git a/crates/rome_js_formatter/src/ts/module/import_type.rs b/crates/rome_js_formatter/src/ts/module/import_type.rs index a16f37d1769..4787a74f46d 100644 --- a/crates/rome_js_formatter/src/ts/module/import_type.rs +++ b/crates/rome_js_formatter/src/ts/module/import_type.rs @@ -1,12 +1,12 @@ use crate::prelude::*; -use crate::utils::FormatLiteralStringToken; +use crate::utils::{FormatLiteralStringToken, StringLiteralParentKind}; use crate::FormatNodeFields; use rome_formatter::write; use rome_js_syntax::TsImportType; use rome_js_syntax::TsImportTypeFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsImportType, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsImportType, f: &mut JsFormatter) -> FormatResult<()> { let TsImportTypeFields { typeof_token, import_token, @@ -26,7 +26,10 @@ impl FormatNodeFields for FormatNodeRule { [ import_token.format(), l_paren_token.format(), - FormatLiteralStringToken::from_string(&argument_token?), + FormatLiteralStringToken::new( + &argument_token?, + StringLiteralParentKind::Expression + ), r_paren_token.format(), qualifier_clause.format(), type_arguments.format(), diff --git a/crates/rome_js_formatter/src/ts/module/import_type_qualifier.rs b/crates/rome_js_formatter/src/ts/module/import_type_qualifier.rs index 98a56ad9b79..6717ec91007 100644 --- a/crates/rome_js_formatter/src/ts/module/import_type_qualifier.rs +++ b/crates/rome_js_formatter/src/ts/module/import_type_qualifier.rs @@ -5,7 +5,7 @@ use rome_js_syntax::TsImportTypeQualifier; use rome_js_syntax::TsImportTypeQualifierFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsImportTypeQualifier, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsImportTypeQualifier, f: &mut JsFormatter) -> FormatResult<()> { let TsImportTypeQualifierFields { dot_token, right } = node.as_fields(); write![f, [dot_token.format(), right.format()]] diff --git a/crates/rome_js_formatter/src/ts/statements/declare_statement.rs b/crates/rome_js_formatter/src/ts/statements/declare_statement.rs index 9b1a061d41f..cf58fe3964f 100644 --- a/crates/rome_js_formatter/src/ts/statements/declare_statement.rs +++ b/crates/rome_js_formatter/src/ts/statements/declare_statement.rs @@ -5,7 +5,7 @@ use rome_js_syntax::TsDeclareStatement; use rome_js_syntax::TsDeclareStatementFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsDeclareStatement, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsDeclareStatement, f: &mut JsFormatter) -> FormatResult<()> { let TsDeclareStatementFields { declaration, declare_token, diff --git a/crates/rome_js_formatter/src/ts/types/any_type.rs b/crates/rome_js_formatter/src/ts/types/any_type.rs index 4c54b3ec4a9..b638059b5c8 100644 --- a/crates/rome_js_formatter/src/ts/types/any_type.rs +++ b/crates/rome_js_formatter/src/ts/types/any_type.rs @@ -4,7 +4,7 @@ use rome_formatter::write; use rome_js_syntax::{TsAnyType, TsAnyTypeFields}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsAnyType, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsAnyType, f: &mut JsFormatter) -> FormatResult<()> { let TsAnyTypeFields { any_token } = node.as_fields(); write![f, [any_token.format()]] diff --git a/crates/rome_js_formatter/src/ts/types/array_type.rs b/crates/rome_js_formatter/src/ts/types/array_type.rs index ef50873de40..8fa610f457a 100644 --- a/crates/rome_js_formatter/src/ts/types/array_type.rs +++ b/crates/rome_js_formatter/src/ts/types/array_type.rs @@ -4,7 +4,7 @@ use rome_formatter::write; use rome_js_syntax::{TsArrayType, TsArrayTypeFields}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsArrayType, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsArrayType, f: &mut JsFormatter) -> FormatResult<()> { let TsArrayTypeFields { l_brack_token, element_type, diff --git a/crates/rome_js_formatter/src/ts/types/asserts_return_type.rs b/crates/rome_js_formatter/src/ts/types/asserts_return_type.rs index bc2d7adef1a..f5573e7dc52 100644 --- a/crates/rome_js_formatter/src/ts/types/asserts_return_type.rs +++ b/crates/rome_js_formatter/src/ts/types/asserts_return_type.rs @@ -5,7 +5,7 @@ use rome_js_syntax::TsAssertsReturnType; use rome_js_syntax::TsAssertsReturnTypeFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsAssertsReturnType, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsAssertsReturnType, f: &mut JsFormatter) -> FormatResult<()> { let TsAssertsReturnTypeFields { parameter_name, asserts_token, diff --git a/crates/rome_js_formatter/src/ts/types/big_int_literal_type.rs b/crates/rome_js_formatter/src/ts/types/big_int_literal_type.rs index e33eb7a0252..9e635163bb5 100644 --- a/crates/rome_js_formatter/src/ts/types/big_int_literal_type.rs +++ b/crates/rome_js_formatter/src/ts/types/big_int_literal_type.rs @@ -4,7 +4,7 @@ use rome_formatter::write; use rome_js_syntax::{TsBigIntLiteralType, TsBigIntLiteralTypeFields}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsBigIntLiteralType, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsBigIntLiteralType, f: &mut JsFormatter) -> FormatResult<()> { let TsBigIntLiteralTypeFields { minus_token, literal_token, diff --git a/crates/rome_js_formatter/src/ts/types/bigint_type.rs b/crates/rome_js_formatter/src/ts/types/bigint_type.rs index 4b8b3488433..d06a9928096 100644 --- a/crates/rome_js_formatter/src/ts/types/bigint_type.rs +++ b/crates/rome_js_formatter/src/ts/types/bigint_type.rs @@ -4,7 +4,7 @@ use rome_formatter::write; use rome_js_syntax::{TsBigintType, TsBigintTypeFields}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsBigintType, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsBigintType, f: &mut JsFormatter) -> FormatResult<()> { let TsBigintTypeFields { bigint_token } = node.as_fields(); write![f, [bigint_token.format()]] diff --git a/crates/rome_js_formatter/src/ts/types/boolean_literal_type.rs b/crates/rome_js_formatter/src/ts/types/boolean_literal_type.rs index f9ef758492c..baa72660f50 100644 --- a/crates/rome_js_formatter/src/ts/types/boolean_literal_type.rs +++ b/crates/rome_js_formatter/src/ts/types/boolean_literal_type.rs @@ -4,7 +4,7 @@ use rome_formatter::write; use rome_js_syntax::{TsBooleanLiteralType, TsBooleanLiteralTypeFields}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsBooleanLiteralType, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsBooleanLiteralType, f: &mut JsFormatter) -> FormatResult<()> { let TsBooleanLiteralTypeFields { literal } = node.as_fields(); write![f, [literal.format()]] } diff --git a/crates/rome_js_formatter/src/ts/types/boolean_type.rs b/crates/rome_js_formatter/src/ts/types/boolean_type.rs index 8511fa33602..40508946661 100644 --- a/crates/rome_js_formatter/src/ts/types/boolean_type.rs +++ b/crates/rome_js_formatter/src/ts/types/boolean_type.rs @@ -4,7 +4,7 @@ use rome_formatter::write; use rome_js_syntax::{TsBooleanType, TsBooleanTypeFields}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsBooleanType, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsBooleanType, f: &mut JsFormatter) -> FormatResult<()> { let TsBooleanTypeFields { boolean_token } = node.as_fields(); write![f, [boolean_token.format()]] diff --git a/crates/rome_js_formatter/src/ts/types/conditional_type.rs b/crates/rome_js_formatter/src/ts/types/conditional_type.rs index 770eb8e215d..60bccdd7e9b 100644 --- a/crates/rome_js_formatter/src/ts/types/conditional_type.rs +++ b/crates/rome_js_formatter/src/ts/types/conditional_type.rs @@ -4,7 +4,7 @@ use crate::FormatNodeFields; use rome_js_syntax::TsConditionalType; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsConditionalType, formatter: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsConditionalType, formatter: &mut JsFormatter) -> FormatResult<()> { format_conditional(&Conditional::Type(node.clone()), formatter, false) } } diff --git a/crates/rome_js_formatter/src/ts/types/constructor_type.rs b/crates/rome_js_formatter/src/ts/types/constructor_type.rs index bd7d787ff88..e23fb710485 100644 --- a/crates/rome_js_formatter/src/ts/types/constructor_type.rs +++ b/crates/rome_js_formatter/src/ts/types/constructor_type.rs @@ -5,7 +5,7 @@ use rome_js_syntax::TsConstructorType; use rome_js_syntax::TsConstructorTypeFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsConstructorType, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsConstructorType, f: &mut JsFormatter) -> FormatResult<()> { let TsConstructorTypeFields { abstract_token, new_token, diff --git a/crates/rome_js_formatter/src/ts/types/function_type.rs b/crates/rome_js_formatter/src/ts/types/function_type.rs index 24a59280870..ee3e35ded6e 100644 --- a/crates/rome_js_formatter/src/ts/types/function_type.rs +++ b/crates/rome_js_formatter/src/ts/types/function_type.rs @@ -5,7 +5,7 @@ use rome_js_syntax::TsFunctionType; use rome_js_syntax::TsFunctionTypeFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsFunctionType, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsFunctionType, f: &mut JsFormatter) -> FormatResult<()> { let TsFunctionTypeFields { parameters, fat_arrow_token, diff --git a/crates/rome_js_formatter/src/ts/types/indexed_access_type.rs b/crates/rome_js_formatter/src/ts/types/indexed_access_type.rs index 675c080da62..4e2df57f08a 100644 --- a/crates/rome_js_formatter/src/ts/types/indexed_access_type.rs +++ b/crates/rome_js_formatter/src/ts/types/indexed_access_type.rs @@ -5,7 +5,7 @@ use rome_js_syntax::TsIndexedAccessType; use rome_js_syntax::TsIndexedAccessTypeFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsIndexedAccessType, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsIndexedAccessType, f: &mut JsFormatter) -> FormatResult<()> { let TsIndexedAccessTypeFields { object_type, l_brack_token, diff --git a/crates/rome_js_formatter/src/ts/types/infer_type.rs b/crates/rome_js_formatter/src/ts/types/infer_type.rs index 8c3688d6b69..6531b6f1936 100644 --- a/crates/rome_js_formatter/src/ts/types/infer_type.rs +++ b/crates/rome_js_formatter/src/ts/types/infer_type.rs @@ -4,7 +4,7 @@ use rome_formatter::write; use rome_js_syntax::{TsInferType, TsInferTypeFields}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsInferType, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsInferType, f: &mut JsFormatter) -> FormatResult<()> { let TsInferTypeFields { infer_token, type_parameter, diff --git a/crates/rome_js_formatter/src/ts/types/intersection_type.rs b/crates/rome_js_formatter/src/ts/types/intersection_type.rs index d9768e0facc..e312e698cf1 100644 --- a/crates/rome_js_formatter/src/ts/types/intersection_type.rs +++ b/crates/rome_js_formatter/src/ts/types/intersection_type.rs @@ -1,49 +1,59 @@ use crate::prelude::*; use crate::FormatNodeFields; use rome_formatter::{format_args, write}; -use rome_js_syntax::TsIntersectionType; use rome_js_syntax::TsIntersectionTypeFields; +use rome_js_syntax::{JsSyntaxToken, TsIntersectionType}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsIntersectionType, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsIntersectionType, f: &mut JsFormatter) -> FormatResult<()> { let TsIntersectionTypeFields { leading_separator_token, types, } = node.as_fields(); - let leading_separator_token = format_once(|f| { - match leading_separator_token { - Some(token) => { - // The SyntaxToken is converted into a FormatElement using - // Token::from to strip the token's trivia pieces which are - // then reinserted in format_replaced outside of the - // if_group_breaks block to avoid removing comments when the - // group does not break - write!( - f, - [format_replaced( - &token, - &if_group_breaks(format_args!( - format_trimmed_token(&token), - space_token() - )) - )] - ) - } - None => write!( - f, - [if_group_breaks(format_args![token("&"), space_token()])] - ), - } - }); - write!( f, - [group_elements(indent(format_args!( + [group_elements(&indent(&format_args!( soft_line_break(), - leading_separator_token, + FormatTypeSetLeadingSeparator { + separator: "&", + leading_separator: leading_separator_token.as_ref() + }, types.format() )))] ) } } + +pub(crate) struct FormatTypeSetLeadingSeparator<'a> { + pub(crate) separator: &'static str, + pub(crate) leading_separator: Option<&'a JsSyntaxToken>, +} + +impl Format for FormatTypeSetLeadingSeparator<'_> { + fn fmt(&self, f: &mut JsFormatter) -> FormatResult<()> { + match &self.leading_separator { + Some(token) => { + // The SyntaxToken is converted into a FormatElement using + // Token::from to strip the token's trivia pieces which are + // then reinserted in format_replaced outside of the + // if_group_breaks block to avoid removing comments when the + // group does not break + write!( + f, + [format_replaced( + token, + &if_group_breaks(&format_args!(format_trimmed_token(token), space_token())) + )] + ) + } + None => write!( + f, + [if_group_breaks(&format_args![ + token(self.separator), + space_token() + ])] + ), + } + } +} diff --git a/crates/rome_js_formatter/src/ts/types/mapped_type.rs b/crates/rome_js_formatter/src/ts/types/mapped_type.rs index 1d644969f18..cdfeb7287a6 100644 --- a/crates/rome_js_formatter/src/ts/types/mapped_type.rs +++ b/crates/rome_js_formatter/src/ts/types/mapped_type.rs @@ -5,7 +5,7 @@ use rome_formatter::{format_args, write}; use rome_js_syntax::{TsMappedType, TsMappedTypeFields}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsMappedType, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsMappedType, f: &mut JsFormatter) -> FormatResult<()> { let TsMappedTypeFields { l_curly_token, readonly_modifier, diff --git a/crates/rome_js_formatter/src/ts/types/never_type.rs b/crates/rome_js_formatter/src/ts/types/never_type.rs index 5e0984a3b19..d0375107fd5 100644 --- a/crates/rome_js_formatter/src/ts/types/never_type.rs +++ b/crates/rome_js_formatter/src/ts/types/never_type.rs @@ -4,7 +4,7 @@ use rome_formatter::write; use rome_js_syntax::{TsNeverType, TsNeverTypeFields}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsNeverType, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsNeverType, f: &mut JsFormatter) -> FormatResult<()> { let TsNeverTypeFields { never_token } = node.as_fields(); write![f, [never_token.format()]] } diff --git a/crates/rome_js_formatter/src/ts/types/non_primitive_type.rs b/crates/rome_js_formatter/src/ts/types/non_primitive_type.rs index 9347b8271a2..a55491e81cb 100644 --- a/crates/rome_js_formatter/src/ts/types/non_primitive_type.rs +++ b/crates/rome_js_formatter/src/ts/types/non_primitive_type.rs @@ -4,7 +4,7 @@ use rome_formatter::write; use rome_js_syntax::{TsNonPrimitiveType, TsNonPrimitiveTypeFields}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsNonPrimitiveType, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsNonPrimitiveType, f: &mut JsFormatter) -> FormatResult<()> { let TsNonPrimitiveTypeFields { object_token } = node.as_fields(); write![f, [object_token.format()]] diff --git a/crates/rome_js_formatter/src/ts/types/null_literal_type.rs b/crates/rome_js_formatter/src/ts/types/null_literal_type.rs index 953054b724c..a79b509d534 100644 --- a/crates/rome_js_formatter/src/ts/types/null_literal_type.rs +++ b/crates/rome_js_formatter/src/ts/types/null_literal_type.rs @@ -4,7 +4,7 @@ use rome_formatter::write; use rome_js_syntax::{TsNullLiteralType, TsNullLiteralTypeFields}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsNullLiteralType, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsNullLiteralType, f: &mut JsFormatter) -> FormatResult<()> { let TsNullLiteralTypeFields { literal_token } = node.as_fields(); write![f, [literal_token.format()]] } diff --git a/crates/rome_js_formatter/src/ts/types/number_literal_type.rs b/crates/rome_js_formatter/src/ts/types/number_literal_type.rs index 763ce81c186..a1e3e467774 100644 --- a/crates/rome_js_formatter/src/ts/types/number_literal_type.rs +++ b/crates/rome_js_formatter/src/ts/types/number_literal_type.rs @@ -4,7 +4,7 @@ use rome_formatter::write; use rome_js_syntax::{TsNumberLiteralType, TsNumberLiteralTypeFields}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsNumberLiteralType, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsNumberLiteralType, f: &mut JsFormatter) -> FormatResult<()> { let TsNumberLiteralTypeFields { minus_token, literal_token, diff --git a/crates/rome_js_formatter/src/ts/types/number_type.rs b/crates/rome_js_formatter/src/ts/types/number_type.rs index e47b18fce1b..df80f5ea6e8 100644 --- a/crates/rome_js_formatter/src/ts/types/number_type.rs +++ b/crates/rome_js_formatter/src/ts/types/number_type.rs @@ -4,7 +4,7 @@ use rome_formatter::write; use rome_js_syntax::{TsNumberType, TsNumberTypeFields}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsNumberType, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsNumberType, f: &mut JsFormatter) -> FormatResult<()> { let TsNumberTypeFields { number_token } = node.as_fields(); write![f, [number_token.format()]] diff --git a/crates/rome_js_formatter/src/ts/types/object_type.rs b/crates/rome_js_formatter/src/ts/types/object_type.rs index fed269b23be..c7a09f8c8e1 100644 --- a/crates/rome_js_formatter/src/ts/types/object_type.rs +++ b/crates/rome_js_formatter/src/ts/types/object_type.rs @@ -5,7 +5,7 @@ use rome_formatter::write; use rome_js_syntax::{TsObjectType, TsObjectTypeFields}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsObjectType, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsObjectType, f: &mut JsFormatter) -> FormatResult<()> { let TsObjectTypeFields { l_curly_token, members, diff --git a/crates/rome_js_formatter/src/ts/types/parenthesized_type.rs b/crates/rome_js_formatter/src/ts/types/parenthesized_type.rs index d076a2b8965..37072a24b3e 100644 --- a/crates/rome_js_formatter/src/ts/types/parenthesized_type.rs +++ b/crates/rome_js_formatter/src/ts/types/parenthesized_type.rs @@ -5,7 +5,7 @@ use rome_js_syntax::TsParenthesizedType; use rome_js_syntax::TsParenthesizedTypeFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsParenthesizedType, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsParenthesizedType, f: &mut JsFormatter) -> FormatResult<()> { let TsParenthesizedTypeFields { l_paren_token, ty, diff --git a/crates/rome_js_formatter/src/ts/types/predicate_return_type.rs b/crates/rome_js_formatter/src/ts/types/predicate_return_type.rs index 1f22cda2d0a..95c666ee90b 100644 --- a/crates/rome_js_formatter/src/ts/types/predicate_return_type.rs +++ b/crates/rome_js_formatter/src/ts/types/predicate_return_type.rs @@ -5,7 +5,7 @@ use rome_js_syntax::TsPredicateReturnType; use rome_js_syntax::TsPredicateReturnTypeFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsPredicateReturnType, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsPredicateReturnType, f: &mut JsFormatter) -> FormatResult<()> { let TsPredicateReturnTypeFields { parameter_name, is_token, diff --git a/crates/rome_js_formatter/src/ts/types/reference_type.rs b/crates/rome_js_formatter/src/ts/types/reference_type.rs index 7915a29dcc7..12564fd6ba4 100644 --- a/crates/rome_js_formatter/src/ts/types/reference_type.rs +++ b/crates/rome_js_formatter/src/ts/types/reference_type.rs @@ -4,7 +4,7 @@ use rome_formatter::write; use rome_js_syntax::{TsReferenceType, TsReferenceTypeFields}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsReferenceType, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsReferenceType, f: &mut JsFormatter) -> FormatResult<()> { let TsReferenceTypeFields { name, type_arguments, diff --git a/crates/rome_js_formatter/src/ts/types/string_literal_type.rs b/crates/rome_js_formatter/src/ts/types/string_literal_type.rs index 5d526587349..25c1f2deecf 100644 --- a/crates/rome_js_formatter/src/ts/types/string_literal_type.rs +++ b/crates/rome_js_formatter/src/ts/types/string_literal_type.rs @@ -1,13 +1,19 @@ use crate::prelude::*; -use crate::utils::FormatLiteralStringToken; +use crate::utils::{FormatLiteralStringToken, StringLiteralParentKind}; use crate::FormatNodeFields; use rome_formatter::write; use rome_js_syntax::{TsStringLiteralType, TsStringLiteralTypeFields}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsStringLiteralType, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsStringLiteralType, f: &mut JsFormatter) -> FormatResult<()> { let TsStringLiteralTypeFields { literal_token } = node.as_fields(); - write!(f, [FormatLiteralStringToken::from_string(&literal_token?)]) + write!( + f, + [FormatLiteralStringToken::new( + &literal_token?, + StringLiteralParentKind::Expression + )] + ) } } diff --git a/crates/rome_js_formatter/src/ts/types/string_type.rs b/crates/rome_js_formatter/src/ts/types/string_type.rs index a2909cbaf67..9e4517c40d3 100644 --- a/crates/rome_js_formatter/src/ts/types/string_type.rs +++ b/crates/rome_js_formatter/src/ts/types/string_type.rs @@ -4,7 +4,7 @@ use rome_formatter::write; use rome_js_syntax::{TsStringType, TsStringTypeFields}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsStringType, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsStringType, f: &mut JsFormatter) -> FormatResult<()> { let TsStringTypeFields { string_token } = node.as_fields(); write![f, [string_token.format()]] diff --git a/crates/rome_js_formatter/src/ts/types/symbol_type.rs b/crates/rome_js_formatter/src/ts/types/symbol_type.rs index 7fb8add5039..bef030019b0 100644 --- a/crates/rome_js_formatter/src/ts/types/symbol_type.rs +++ b/crates/rome_js_formatter/src/ts/types/symbol_type.rs @@ -4,7 +4,7 @@ use rome_formatter::write; use rome_js_syntax::{TsSymbolType, TsSymbolTypeFields}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsSymbolType, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsSymbolType, f: &mut JsFormatter) -> FormatResult<()> { let TsSymbolTypeFields { symbol_token } = node.as_fields(); write![f, [symbol_token.format()]] diff --git a/crates/rome_js_formatter/src/ts/types/this_type.rs b/crates/rome_js_formatter/src/ts/types/this_type.rs index a38836f4485..4e2973a25df 100644 --- a/crates/rome_js_formatter/src/ts/types/this_type.rs +++ b/crates/rome_js_formatter/src/ts/types/this_type.rs @@ -4,7 +4,7 @@ use rome_formatter::write; use rome_js_syntax::{TsThisType, TsThisTypeFields}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsThisType, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsThisType, f: &mut JsFormatter) -> FormatResult<()> { let TsThisTypeFields { this_token } = node.as_fields(); write![f, [this_token.format()]] diff --git a/crates/rome_js_formatter/src/ts/types/tuple_type.rs b/crates/rome_js_formatter/src/ts/types/tuple_type.rs index cbd29895fa2..204dc722925 100644 --- a/crates/rome_js_formatter/src/ts/types/tuple_type.rs +++ b/crates/rome_js_formatter/src/ts/types/tuple_type.rs @@ -4,7 +4,7 @@ use rome_formatter::write; use rome_js_syntax::{TsTupleType, TsTupleTypeFields}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsTupleType, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsTupleType, f: &mut JsFormatter) -> FormatResult<()> { let TsTupleTypeFields { l_brack_token, elements, diff --git a/crates/rome_js_formatter/src/ts/types/type_operator_type.rs b/crates/rome_js_formatter/src/ts/types/type_operator_type.rs index b4c107d6194..4253d1c72d7 100644 --- a/crates/rome_js_formatter/src/ts/types/type_operator_type.rs +++ b/crates/rome_js_formatter/src/ts/types/type_operator_type.rs @@ -4,7 +4,7 @@ use rome_formatter::write; use rome_js_syntax::{TsTypeOperatorType, TsTypeOperatorTypeFields}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsTypeOperatorType, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsTypeOperatorType, f: &mut JsFormatter) -> FormatResult<()> { let TsTypeOperatorTypeFields { operator_token, ty } = node.as_fields(); write![f, [operator_token.format(), space_token(), ty.format()]] diff --git a/crates/rome_js_formatter/src/ts/types/typeof_type.rs b/crates/rome_js_formatter/src/ts/types/typeof_type.rs index 5b645a85dbd..dfb18c2928c 100644 --- a/crates/rome_js_formatter/src/ts/types/typeof_type.rs +++ b/crates/rome_js_formatter/src/ts/types/typeof_type.rs @@ -4,7 +4,7 @@ use rome_formatter::write; use rome_js_syntax::{TsTypeofType, TsTypeofTypeFields}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsTypeofType, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsTypeofType, f: &mut JsFormatter) -> FormatResult<()> { let TsTypeofTypeFields { typeof_token, expression_name, diff --git a/crates/rome_js_formatter/src/ts/types/undefined_type.rs b/crates/rome_js_formatter/src/ts/types/undefined_type.rs index 2c0ae955e79..2bad1a8a9c2 100644 --- a/crates/rome_js_formatter/src/ts/types/undefined_type.rs +++ b/crates/rome_js_formatter/src/ts/types/undefined_type.rs @@ -4,7 +4,7 @@ use rome_formatter::write; use rome_js_syntax::{TsUndefinedType, TsUndefinedTypeFields}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsUndefinedType, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsUndefinedType, f: &mut JsFormatter) -> FormatResult<()> { let TsUndefinedTypeFields { undefined_token } = node.as_fields(); write![f, [undefined_token.format()]] diff --git a/crates/rome_js_formatter/src/ts/types/union_type.rs b/crates/rome_js_formatter/src/ts/types/union_type.rs index 9652c5ddfe4..3646b98a683 100644 --- a/crates/rome_js_formatter/src/ts/types/union_type.rs +++ b/crates/rome_js_formatter/src/ts/types/union_type.rs @@ -1,44 +1,28 @@ use crate::prelude::*; +use crate::ts::types::intersection_type::FormatTypeSetLeadingSeparator; use crate::FormatNodeFields; use rome_formatter::{format_args, write, Buffer, VecBuffer}; use rome_js_syntax::TsUnionType; use rome_js_syntax::TsUnionTypeFields; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsUnionType, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsUnionType, f: &mut JsFormatter) -> FormatResult<()> { let TsUnionTypeFields { leading_separator_token, types, } = node.as_fields(); - let format_leading_separator_token = format_once(|f| { - match leading_separator_token { - Some(token) => { - // The SyntaxToken is converted into a FormatElement using - // Token::from to strip the token's trivia pieces which are - // then reinserted in format_replaced outside of the - // if_group_breaks block to avoid removing comments when the - // group does not break - write!( - f, - [format_replaced( - &token, - &if_group_breaks(format_args!( - format_trimmed_token(&token), - space_token() - )) - )] - ) - } - None => write!( - f, - [if_group_breaks(format_args![token("|"), space_token()])] - ), - } - }); - let mut buffer = VecBuffer::new(f.state_mut()); - write!(buffer, [types.format()])?; + write!( + buffer, + [ + FormatTypeSetLeadingSeparator { + separator: "|", + leading_separator: leading_separator_token.as_ref() + }, + types.format() + ] + )?; let types = buffer.into_element(); @@ -49,9 +33,8 @@ impl FormatNodeFields for FormatNodeRule { write![ f, [ - group_elements(indent(format_args![ + group_elements(&indent(&format_args![ soft_line_break(), - format_leading_separator_token, format_once(|f| { f.write_element(leading_comments)?; f.write_element(types) diff --git a/crates/rome_js_formatter/src/ts/types/unknown_type.rs b/crates/rome_js_formatter/src/ts/types/unknown_type.rs index 81ef3133ace..a07c0051513 100644 --- a/crates/rome_js_formatter/src/ts/types/unknown_type.rs +++ b/crates/rome_js_formatter/src/ts/types/unknown_type.rs @@ -4,7 +4,7 @@ use rome_formatter::write; use rome_js_syntax::{TsUnknownType, TsUnknownTypeFields}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsUnknownType, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsUnknownType, f: &mut JsFormatter) -> FormatResult<()> { let TsUnknownTypeFields { unknown_token } = node.as_fields(); write![f, [unknown_token.format()]] diff --git a/crates/rome_js_formatter/src/ts/types/void_type.rs b/crates/rome_js_formatter/src/ts/types/void_type.rs index a6797e15427..2297a999d26 100644 --- a/crates/rome_js_formatter/src/ts/types/void_type.rs +++ b/crates/rome_js_formatter/src/ts/types/void_type.rs @@ -4,7 +4,7 @@ use rome_formatter::write; use rome_js_syntax::{TsVoidType, TsVoidTypeFields}; impl FormatNodeFields for FormatNodeRule { - fn format_fields(node: &TsVoidType, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt_fields(node: &TsVoidType, f: &mut JsFormatter) -> FormatResult<()> { let TsVoidTypeFields { void_token } = node.as_fields(); write![f, [void_token.format()]] diff --git a/crates/rome_js_formatter/src/utils/array.rs b/crates/rome_js_formatter/src/utils/array.rs index c4027ef12d9..3bad82e4989 100644 --- a/crates/rome_js_formatter/src/utils/array.rs +++ b/crates/rome_js_formatter/src/utils/array.rs @@ -9,7 +9,7 @@ use rome_js_syntax::{ use rome_rowan::{AstNode, AstSeparatedList}; /// Utility function to print array-like nodes (array expressions, array bindings and assignment patterns) -pub(crate) fn format_array_node(node: &N, f: &mut JsFormatter) -> FormatResult<()> +pub(crate) fn write_array_node(node: &N, f: &mut JsFormatter) -> FormatResult<()> where N: AstSeparatedList, for<'a> I: ArrayNodeElement + AsFormat<'a>, @@ -31,7 +31,7 @@ where join.entry( node.syntax(), &format_with(|f| { - write!(f, [group_elements(node.format())])?; + write!(f, [group_elements(&node.format())])?; if is_disallow { // Trailing separators are disallowed, replace it with an empty element @@ -47,10 +47,10 @@ where } else if let Some(separator) = element.trailing_separator()? { write!( f, - [format_replaced(separator, &if_group_breaks(token(",")))] + [format_replaced(separator, &if_group_breaks(&token(",")))] )?; } else { - write!(f, [if_group_breaks(token(","))])?; + write!(f, [if_group_breaks(&token(","))])?; }; Ok(()) diff --git a/crates/rome_js_formatter/src/utils/binary_like_expression.rs b/crates/rome_js_formatter/src/utils/binary_like_expression.rs index e8dca5ce105..fc8200d88e7 100644 --- a/crates/rome_js_formatter/src/utils/binary_like_expression.rs +++ b/crates/rome_js_formatter/src/utils/binary_like_expression.rs @@ -238,9 +238,9 @@ where f.write_element(leading)?; write![ f, - [group_elements(format_args![ + [group_elements(&format_args![ token("("), - soft_block_indent(format_once(|f| { + soft_block_indent(&format_once(|f| { f.write_element(content)?; f.write_element(trailing) })), @@ -536,7 +536,7 @@ impl FlattenedExpression { } else if should_not_indent_if_parent_indents(current.syntax()) { write!( f, - [group_elements(format_once(|f| { + [group_elements(&format_once(|f| { f.join_with(soft_line_break_or_space()) .entries(groups) .finish() @@ -548,7 +548,7 @@ impl FlattenedExpression { // that behave differently depending on the situation write!( f, - [soft_line_indent_or_space(&group_elements(format_once( + [soft_line_indent_or_space(&group_elements(&format_once( |f| { f.join_with(soft_line_break_or_space()) .entries(groups) @@ -564,7 +564,7 @@ impl FlattenedExpression { write!( f, - [group_elements(soft_line_indent_or_space(&format_once( + [group_elements(&soft_line_indent_or_space(&format_once( |f| { f.join_with(soft_line_break_or_space()) .entries(groups) @@ -942,7 +942,7 @@ impl AstNode for JsAnyBinaryLikeLeftExpression { } impl Format for JsAnyBinaryLikeLeftExpression { - fn format(&self, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(&self, f: &mut JsFormatter) -> FormatResult<()> { match self { JsAnyBinaryLikeLeftExpression::JsAnyExpression(expression) => { write![f, [expression.format()]] diff --git a/crates/rome_js_formatter/src/utils/format_conditional.rs b/crates/rome_js_formatter/src/utils/format_conditional.rs index 1924e0f6e9e..d4d60042303 100644 --- a/crates/rome_js_formatter/src/utils/format_conditional.rs +++ b/crates/rome_js_formatter/src/utils/format_conditional.rs @@ -81,7 +81,7 @@ impl Conditional { let _body = if left_or_right_is_conditional || parent_is_conditional { write!( f, - [indent(format_args![ + [indent(&format_args![ hard_line_break(), format_consequent, hard_line_break(), @@ -91,7 +91,7 @@ impl Conditional { } else { write!( f, - [group_elements(format_args![ + [group_elements(&format_args![ space_token(), format_consequent, space_token(), diff --git a/crates/rome_js_formatter/src/utils/member_chain/groups.rs b/crates/rome_js_formatter/src/utils/member_chain/groups.rs index 3b8b798bbda..2547fbe216d 100644 --- a/crates/rome_js_formatter/src/utils/member_chain/groups.rs +++ b/crates/rome_js_formatter/src/utils/member_chain/groups.rs @@ -109,7 +109,7 @@ impl Groups { [format_once(|f| { let formatted_groups = self.into_formatted_groups(); - f.join_with(hard_line_break()) + f.join_with(&hard_line_break()) .entries( formatted_groups .into_iter() diff --git a/crates/rome_js_formatter/src/utils/member_chain/mod.rs b/crates/rome_js_formatter/src/utils/member_chain/mod.rs index 9282b42bbc9..69de5102814 100644 --- a/crates/rome_js_formatter/src/utils/member_chain/mod.rs +++ b/crates/rome_js_formatter/src/utils/member_chain/mod.rs @@ -293,7 +293,7 @@ fn format_groups( if groups.groups_should_break(calls_count)? { write!( f, - [indent(format_args!( + [indent(&format_args!( hard_line_break(), format_once(|f| { f.write_element(groups.into_joined_hard_line_groups())?; diff --git a/crates/rome_js_formatter/src/utils/mod.rs b/crates/rome_js_formatter/src/utils/mod.rs index 0b2f964a173..58013b3c96e 100644 --- a/crates/rome_js_formatter/src/utils/mod.rs +++ b/crates/rome_js_formatter/src/utils/mod.rs @@ -14,9 +14,11 @@ pub(crate) use format_conditional::{format_conditional, Conditional}; pub(crate) use member_chain::format_call_expression; use rome_formatter::{normalize_newlines, write, Buffer, VecBuffer}; use rome_js_syntax::suppression::{has_suppressions_category, SuppressionCategory}; +use rome_js_syntax::JsSyntaxKind::JS_STRING_LITERAL; use rome_js_syntax::{ - JsAnyExpression, JsAnyFunction, JsAnyStatement, JsInitializerClause, JsLanguage, - JsTemplateElement, Modifiers, TsTemplateElement, TsType, + JsAnyClassMemberName, JsAnyExpression, JsAnyFunction, JsAnyObjectMemberName, JsAnyStatement, + JsComputedMemberName, JsInitializerClause, JsLanguage, JsLiteralMemberName, + JsPrivateClassMemberName, JsTemplateElement, Modifiers, TsTemplateElement, TsType, }; use rome_js_syntax::{JsSyntaxKind, JsSyntaxNode, JsSyntaxToken}; use rome_rowan::{AstNode, AstNodeList, SyntaxResult}; @@ -41,7 +43,7 @@ impl<'a> FormatTypeMemberSeparator<'a> { } impl Format for FormatTypeMemberSeparator<'_> { - fn format(&self, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(&self, f: &mut JsFormatter) -> FormatResult<()> { if let Some(separator) = self.token { write!(f, [format_replaced(separator, &empty_element())]) } else { @@ -62,7 +64,7 @@ impl<'a> FormatInitializerClause<'a> { } impl Format for FormatInitializerClause<'_> { - fn format(&self, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(&self, f: &mut JsFormatter) -> FormatResult<()> { if let Some(initializer) = self.initializer { write!(f, [space_token(), initializer.format()]) } else { @@ -84,7 +86,7 @@ impl<'a> FormatInterpreterToken<'a> { } impl Format for FormatInterpreterToken<'_> { - fn format(&self, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(&self, f: &mut JsFormatter) -> FormatResult<()> { if let Some(interpreter) = self.token { write!(f, [interpreter.format(), empty_line()]) } else { @@ -157,7 +159,7 @@ impl<'a> FormatBodyStatement<'a> { } impl Format for FormatBodyStatement<'_> { - fn format(&self, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(&self, f: &mut JsFormatter) -> FormatResult<()> { match self.body { JsAnyStatement::JsEmptyStatement(body) => { write!(f, [body.format(), token(";")]) @@ -219,7 +221,7 @@ pub(crate) enum TemplateElement { } impl Format for TemplateElement { - fn format(&self, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(&self, f: &mut JsFormatter) -> FormatResult<()> { let expression_is_plain = self.is_plain_expression()?; let has_comments = self.has_comments(); let should_hard_group = expression_is_plain && !has_comments; @@ -415,7 +417,7 @@ impl<'a> FormatWithSemicolon<'a> { } impl Format for FormatWithSemicolon<'_> { - fn format(&self, f: &mut JsFormatter) -> FormatResult<()> { + fn fmt(&self, f: &mut JsFormatter) -> FormatResult<()> { let mut buffer = VecBuffer::new(f.state_mut()); write!(buffer, [self.content])?; @@ -451,3 +453,71 @@ pub(crate) fn is_call_like_expression(expression: &JsAnyExpression) -> bool { | JsAnyExpression::JsCallExpression(_) ) } + +/// Data structure used to merge into one the following nodes: +/// +/// - [JsAnyObjectMemberName] +/// - [JsAnyClassMemberName] +/// - [JsLiteralMemberName] +/// +/// Once merged, the enum is used to get specific members (the literal ones) and elide +/// the quotes from them, when the algorithm sees fit +#[allow(clippy::enum_variant_names)] +pub(crate) enum FormatMemberName { + ComputedMemberName(JsComputedMemberName), + PrivateClassMemberName(JsPrivateClassMemberName), + LiteralMemberName(JsLiteralMemberName), +} + +impl From for FormatMemberName { + fn from(node: JsAnyClassMemberName) -> Self { + match node { + JsAnyClassMemberName::JsComputedMemberName(node) => Self::ComputedMemberName(node), + JsAnyClassMemberName::JsLiteralMemberName(node) => Self::LiteralMemberName(node), + JsAnyClassMemberName::JsPrivateClassMemberName(node) => { + Self::PrivateClassMemberName(node) + } + } + } +} + +impl From for FormatMemberName { + fn from(node: JsAnyObjectMemberName) -> Self { + match node { + JsAnyObjectMemberName::JsComputedMemberName(node) => Self::ComputedMemberName(node), + JsAnyObjectMemberName::JsLiteralMemberName(node) => Self::LiteralMemberName(node), + } + } +} + +impl From for FormatMemberName { + fn from(literal: JsLiteralMemberName) -> Self { + Self::LiteralMemberName(literal) + } +} + +impl Format for FormatMemberName { + fn fmt(&self, f: &mut JsFormatter) -> FormatResult<()> { + match self { + FormatMemberName::ComputedMemberName(node) => { + write![f, [node.format()]] + } + FormatMemberName::PrivateClassMemberName(node) => { + write![f, [node.format()]] + } + FormatMemberName::LiteralMemberName(literal) => { + let value = literal.value()?; + + if value.kind() == JS_STRING_LITERAL { + FormatLiteralStringToken::new( + &literal.value()?, + StringLiteralParentKind::Member, + ) + .fmt(f) + } else { + value.format().fmt(f) + } + } + } + } +} diff --git a/crates/rome_js_formatter/src/utils/string_utils.rs b/crates/rome_js_formatter/src/utils/string_utils.rs index ae22fe2616d..1c30e28146a 100644 --- a/crates/rome_js_formatter/src/utils/string_utils.rs +++ b/crates/rome_js_formatter/src/utils/string_utils.rs @@ -2,7 +2,8 @@ use crate::context::QuoteStyle; use crate::prelude::*; use crate::utils::string_utils::CharSignal::AlreadyPrinted; use rome_formatter::{write, Buffer}; -use rome_js_syntax::JsSyntaxToken; +use rome_js_syntax::JsSyntaxKind::JS_STRING_LITERAL; +use rome_js_syntax::{JsSyntaxToken, SourceType}; use std::borrow::Cow; pub trait ToAsciiLowercaseCow { @@ -42,33 +43,46 @@ impl ToAsciiLowercaseCow for String { const CHARACTERS_THAT_COULD_KEEP_THE_ESCAPE: [char; 4] = ['\\', '\'', '"', '\r']; -pub(crate) enum FormatLiteralStringToken<'token> { - String(&'token JsSyntaxToken), - Directive(&'token JsSyntaxToken), +#[derive(Eq, PartialEq, Debug)] +pub(crate) enum StringLiteralParentKind { + /// Variant to track tokens that are inside an expression + Expression, + /// Variant to track tokens that are inside a member + Member, + /// Variant used when the string literal is inside a directive. This will apply + /// a simplified logic of normalisation + Directive, +} + +/// Data structure of convenience to format string literals +pub(crate) struct FormatLiteralStringToken<'token> { + /// The current token + token: &'token JsSyntaxToken, + + /// The parent that holds the token + parent_kind: StringLiteralParentKind, } impl<'token> FormatLiteralStringToken<'token> { - pub fn from_directive(token: &'token JsSyntaxToken) -> Self { - Self::Directive(token) - } - pub fn from_string(token: &'token JsSyntaxToken) -> Self { - Self::String(token) + pub fn new(token: &'token JsSyntaxToken, parent_kind: StringLiteralParentKind) -> Self { + Self { token, parent_kind } } + pub fn token(&self) -> &'token JsSyntaxToken { - match self { - FormatLiteralStringToken::String(token) => token, - FormatLiteralStringToken::Directive(token) => token, - } + self.token } } impl Format for FormatLiteralStringToken<'_> { - fn format(&self, f: &mut JsFormatter) -> FormatResult<()> { - let chosen_quote_style = f.context().quote_style(); + fn fmt(&self, f: &mut JsFormatter) -> FormatResult<()> { let token = self.token(); + debug_assert_eq!(token.kind(), JS_STRING_LITERAL); + + let chosen_quote_style = f.context().quote_style(); + let mut string_cleaner = LiteralStringNormaliser::new(self, chosen_quote_style); - let content = string_cleaner.clean_text(); + let content = string_cleaner.normalise_text(f.context().source_type.into()); write!( f, @@ -80,82 +94,18 @@ impl Format for FormatLiteralStringToken<'_> { } } -/// This signal is used to tell to the next character what it should do -enum CharSignal { - /// There hasn't been any signal - None, - /// The function decided to keep the previous character - Keep, - /// The function has decided to print the character. Saves the character that was - /// already written - AlreadyPrinted(char), -} - -/// Struct of convenience used to manipulate the string. It saves some state in order to apply -/// the normalise process. -pub(crate) struct LiteralStringNormaliser<'token> { - token: &'token FormatLiteralStringToken<'token>, - /// This is the quote that is set in the formatter options - chosen_quote: QuoteStyle, +/// Data structure of convenience to store some information about the +/// string that has been processed +struct StringInformation { /// This is the quote that the is calculated and eventually used inside the string. /// It could be different from the one inside the formatter options - preferred_quote: Option, + preferred_quote: QuoteStyle, /// It flags if the raw content has quotes (single or double). The raw content is the /// content of a string literal without the quotes - raw_content_has_quotes: Option, - /// Checks of the literal token passed to the function starts without quotes. - /// - /// literal, in our syntax, might not have quotes so we need to check if they start with a possible quote - /// and if so, they are eligible for possible string manipulation - /// For example: - /// ```js - /// export { a as "b" }; - /// export { a as b }; - /// ``` - /// - /// `b` and `"b"` are both defined as literals in our grammar - literal_starts_with_quote: Option, + raw_content_has_quotes: bool, } -impl<'token> LiteralStringNormaliser<'token> { - pub fn new( - token: &'token FormatLiteralStringToken<'_>, - chosen_quote_style: QuoteStyle, - ) -> Self { - Self { - token, - chosen_quote: chosen_quote_style, - preferred_quote: None, - raw_content_has_quotes: None, - literal_starts_with_quote: None, - } - } - - pub fn clean_text(&mut self) -> Cow { - self.compute_preferred_quote(); - match self.token { - FormatLiteralStringToken::String(_) => self.clean_string_literal(), - FormatLiteralStringToken::Directive(_) => self.clean_directive(), - } - } - - fn get_token(&self) -> &'token JsSyntaxToken { - match self.token { - FormatLiteralStringToken::String(token) => token, - FormatLiteralStringToken::Directive(token) => token, - } - } - - fn can_reduce_escapes(&self) -> bool { - if matches!(self.token, FormatLiteralStringToken::Directive(_)) { - !self - .raw_content_has_quotes - .expect("You must compute the quotes in order to know this information") - } else { - true - } - } - +impl FormatLiteralStringToken<'_> { /// This function determines which quotes should be used inside to enclose the string. /// The function take as a input the string **without quotes**. /// @@ -181,27 +131,18 @@ impl<'token> LiteralStringNormaliser<'token> { /// (' content """ dont\'t ') /// ``` /// Like this, we reduced the number of escaped quotes. - fn compute_preferred_quote(&mut self) { - let literal = self.get_token().text_trimmed(); - let alternate = self.chosen_quote.other(); - let mut literal_starts_with_quote = None; + fn compute_string_information(&self, chosen_quote: QuoteStyle) -> StringInformation { + let literal = self.token().text_trimmed(); + let alternate = chosen_quote.other(); let char_count = literal.chars().count(); let (preferred_quotes_count, alternate_quotes_count) = literal.chars().enumerate().fold( (0, 0), |(preferred_quotes_counter, alternate_quotes_counter), (index, current_character)| { - if index == 0 { - let chosen_quote_char = self.chosen_quote.as_char(); - let alternate_quote_char = alternate.as_char(); - literal_starts_with_quote = Some( - current_character == chosen_quote_char - || current_character == alternate_quote_char, - ); - (preferred_quotes_counter, alternate_quotes_counter) - } else if index == char_count - 1 { + if index == 0 || index == char_count - 1 { (preferred_quotes_counter, alternate_quotes_counter) - } else if current_character == self.chosen_quote.as_char() { + } else if current_character == chosen_quote.as_char() { (preferred_quotes_counter + 1, alternate_quotes_counter) } else if current_character == alternate.as_char() { (preferred_quotes_counter, alternate_quotes_counter + 1) @@ -211,42 +152,148 @@ impl<'token> LiteralStringNormaliser<'token> { }, ); - self.literal_starts_with_quote = literal_starts_with_quote; - if preferred_quotes_count > alternate_quotes_count { - self.preferred_quote = Some(alternate) + StringInformation { + raw_content_has_quotes: preferred_quotes_count > 0 || alternate_quotes_count > 0, + preferred_quote: if preferred_quotes_count > alternate_quotes_count { + alternate + } else { + chosen_quote + }, + } + } +} + +/// This signal is used to tell to the next character what it should do +enum CharSignal { + /// There hasn't been any signal + None, + /// The function decided to keep the previous character + Keep, + /// The function has decided to print the character. Saves the character that was + /// already written + AlreadyPrinted(char), +} + +/// Struct of convenience used to manipulate the string. It saves some state in order to apply +/// the normalise process. +struct LiteralStringNormaliser<'token> { + /// The current token + token: &'token FormatLiteralStringToken<'token>, + /// The quote that was set inside the configuration + chosen_quote: QuoteStyle, +} + +/// Convenience enum to map [rome_js_syntax::SourceType] by just reading +/// the type of file +#[derive(Eq, PartialEq)] +pub(crate) enum SourceFileKind { + TypeScript, + JavaScript, +} + +impl From for SourceFileKind { + fn from(st: SourceType) -> Self { + if st.language().is_typescript() { + Self::TypeScript + } else { + Self::JavaScript + } + } +} + +impl<'token> LiteralStringNormaliser<'token> { + pub fn new(token: &'token FormatLiteralStringToken<'_>, chosen_quote: QuoteStyle) -> Self { + Self { + token, + chosen_quote, + } + } + + pub fn normalise_text(&mut self, file_source: SourceFileKind) -> Cow { + let string_information = self.token.compute_string_information(self.chosen_quote); + match self.token.parent_kind { + StringLiteralParentKind::Expression => { + self.normalise_string_literal(string_information) + } + StringLiteralParentKind::Directive => self.normalise_directive(&string_information), + StringLiteralParentKind::Member => { + self.normalise_type_member(string_information, file_source) + } + } + } + + fn get_token(&self) -> &'token JsSyntaxToken { + self.token.token() + } + + fn can_reduce_escapes(&self, string_information: &StringInformation) -> bool { + if matches!(self.token.parent_kind, StringLiteralParentKind::Directive) { + !string_information.raw_content_has_quotes } else { - self.preferred_quote = Some(self.chosen_quote); + true } - self.raw_content_has_quotes = - Some(preferred_quotes_count > 0 || alternate_quotes_count > 0); } - fn clean_directive(&mut self) -> Cow { - let content = self.normalize_string(); + fn normalise_directive(&mut self, string_information: &StringInformation) -> Cow { + let content = self.normalize_string(string_information); match content { - Cow::Borrowed(content) => self.swap_quotes(content), - Cow::Owned(content) => Cow::Owned(self.swap_quotes(content.as_ref()).into_owned()), + Cow::Borrowed(content) => self.swap_quotes(content, string_information), + Cow::Owned(content) => Cow::Owned( + self.swap_quotes(content.as_ref(), string_information) + .into_owned(), + ), } } - fn clean_string_literal(&self) -> Cow<'token, str> { - let literal = self.get_token().text_trimmed(); - let preferred_quote = self - .preferred_quote - .expect("You must compute the preferred quote style first"); + /// We can change the text only if there are alphanumeric or alphabetic characters, depending on the file source + fn can_remove_quotes(&self, file_source: SourceFileKind) -> bool { + let text_to_check = self.raw_content(); + // Text here is quoteless. If it's empty, it means it is an empty string and we can't + // do any transformation + if text_to_check.is_empty() { + return false; + } + + let mut has_seen_number = false; + text_to_check.chars().enumerate().all(|(index, c)| { + if index == 0 && c.is_numeric() { + // In TypeScript, numbers like members have different meaning from numbers. + // Hence, if we see a number, we bail straightaway + if file_source == SourceFileKind::TypeScript { + return false; + } else { + has_seen_number = true; + } + } + + let is_eligible_character = if has_seen_number { + // as we've seen a number, now eligible characters can only contain numbers + c.is_numeric() + } else { + c.is_alphanumeric() + }; + is_eligible_character || matches!(c, '_' | '$') + }) + } - if !self - .literal_starts_with_quote - .expect("You must compute the preferred quote style first") - { - return Cow::Borrowed(literal); + fn normalise_type_member( + &mut self, + string_information: StringInformation, + file_source: SourceFileKind, + ) -> Cow { + if self.can_remove_quotes(file_source) { + return Cow::Owned(self.raw_content().to_string()); } + self.normalise_string_literal(string_information) + } - let polished_raw_content = self.normalize_string(); + fn normalise_string_literal(&self, string_information: StringInformation) -> Cow<'token, str> { + let preferred_quote = string_information.preferred_quote; + let polished_raw_content = self.normalize_string(&string_information); match polished_raw_content { Cow::Borrowed(raw_content) => { - let final_content = self.swap_quotes(raw_content); + let final_content = self.swap_quotes(raw_content, &string_information); match final_content { Cow::Borrowed(final_content) => Cow::Borrowed(final_content), Cow::Owned(final_content) => Cow::Owned(final_content), @@ -311,17 +358,15 @@ impl<'token> LiteralStringNormaliser<'token> { /// /// By default the formatter uses `\n` as a newline. The function replaces /// `\r\n` with `\n`, - fn normalize_string(&self) -> Cow<'token, str> { - let preferred_quote = self - .preferred_quote - .expect("You must compute the preferred quote style first"); + fn normalize_string(&self, string_information: &StringInformation) -> Cow<'token, str> { + let preferred_quote = string_information.preferred_quote; let alternate_quote = preferred_quote.other(); let mut reduced_string = String::new(); let mut last_end = 0; let mut signal = CharSignal::None; let raw_content = self.raw_content(); - let can_reduce_escapes = self.can_reduce_escapes(); + let can_reduce_escapes = self.can_reduce_escapes(string_information); for (start, part) in raw_content.match_indices(CHARACTERS_THAT_COULD_KEEP_THE_ESCAPE) { if start - last_end >= 1 { @@ -364,9 +409,7 @@ impl<'token> LiteralStringNormaliser<'token> { } _ => { reduced_string.push(alternate_quote.as_char()); - signal = CharSignal::AlreadyPrinted( - alternate_quote.as_char(), - ); + signal = AlreadyPrinted(alternate_quote.as_char()); } } } else { @@ -461,16 +504,16 @@ impl<'token> LiteralStringNormaliser<'token> { &content[1..content.len() - 1] } - fn swap_quotes>(&self, content_to_use: S) -> Cow<'token, str> { + fn swap_quotes>( + &self, + content_to_use: S, + string_information: &StringInformation, + ) -> Cow<'token, str> { let original_content = self.get_token().text_trimmed(); - let preferred_quote = self - .preferred_quote - .expect("You must compute the preferred quote style first"); + let preferred_quote = string_information.preferred_quote; let other_quote = preferred_quote.other().as_char(); - let raw_content_has_quotes = self - .raw_content_has_quotes - .expect("You must compute the quotes in order to know this information"); + let raw_content_has_quotes = string_information.raw_content_has_quotes; if raw_content_has_quotes { Cow::Borrowed(original_content) @@ -490,8 +533,15 @@ impl<'token> LiteralStringNormaliser<'token> { #[cfg(test)] mod tests { use super::*; + use crate::context::QuoteStyle; use crate::utils::quickcheck_utils::*; + use crate::utils::FormatLiteralStringToken; use quickcheck_macros::*; + use rome_js_factory::JsSyntaxTreeBuilder; + use rome_js_syntax::JsSyntaxKind::{JS_STRING_LITERAL, JS_STRING_LITERAL_EXPRESSION}; + use rome_js_syntax::{JsStringLiteralExpression, JsSyntaxToken}; + use rome_rowan::AstNode; + use std::borrow::Cow; #[quickcheck] fn to_ascii_lowercase_cow_always_returns_same_value_as_string_to_lowercase(txt: AsciiString) { @@ -512,18 +562,6 @@ mod tests { let txt = std::format!("{}A", txt); //guarantees at least one uppercase letter assert!(matches!(txt.to_ascii_lowercase_cow(), Cow::Owned(s) if s == txt.to_lowercase())); } -} - -#[cfg(test)] -mod string_literal_tests { - use super::LiteralStringNormaliser; - use crate::context::QuoteStyle; - use crate::utils::FormatLiteralStringToken; - use rome_js_factory::JsSyntaxTreeBuilder; - use rome_js_syntax::JsSyntaxKind::{JS_STRING_LITERAL, JS_STRING_LITERAL_EXPRESSION}; - use rome_js_syntax::{JsStringLiteralExpression, JsSyntaxToken}; - use rome_rowan::AstNode; - use std::borrow::Cow; fn generate_syntax_token(input: &str) -> JsSyntaxToken { let mut tree_builder = JsSyntaxTreeBuilder::new(); @@ -539,27 +577,52 @@ mod string_literal_tests { .unwrap() } - fn assert_borrowed_token(input: &str, quote: QuoteStyle, as_directive: bool) { + enum AsToken { + Directive, + String, + Member, + } + + impl AsToken { + fn into_token(self, token: &JsSyntaxToken) -> FormatLiteralStringToken { + match self { + AsToken::Directive => { + FormatLiteralStringToken::new(token, StringLiteralParentKind::Directive) + } + AsToken::String => { + FormatLiteralStringToken::new(token, StringLiteralParentKind::Expression) + } + AsToken::Member => { + FormatLiteralStringToken::new(token, StringLiteralParentKind::Member) + } + } + } + } + + fn assert_borrowed_token( + input: &str, + quote: QuoteStyle, + as_token: AsToken, + source: SourceFileKind, + ) { let token = generate_syntax_token(input); - let string_token = if as_directive { - FormatLiteralStringToken::from_directive(&token) - } else { - FormatLiteralStringToken::from_string(&token) - }; + let string_token = as_token.into_token(&token); let mut string_cleaner = LiteralStringNormaliser::new(&string_token, quote); - let content = string_cleaner.clean_text(); + let content = string_cleaner.normalise_text(source); assert_eq!(content, Cow::Borrowed(input)) } - fn assert_owned_token(input: &str, output: &str, quote: QuoteStyle, as_directive: bool) { + fn assert_owned_token( + input: &str, + output: &str, + quote: QuoteStyle, + as_token: AsToken, + source: SourceFileKind, + ) { let token = generate_syntax_token(input); - let string_token = if as_directive { - FormatLiteralStringToken::from_directive(&token) - } else { - FormatLiteralStringToken::from_string(&token) - }; + let string_token = as_token.into_token(&token); let mut string_cleaner = LiteralStringNormaliser::new(&string_token, quote); - let content = string_cleaner.clean_text(); + let content = string_cleaner.normalise_text(source); let owned: Cow = Cow::Owned(output.to_string()); assert_eq!(content, owned) } @@ -569,7 +632,7 @@ mod string_literal_tests { let quote = QuoteStyle::Double; let inputs = [r#""content""#, r#""content with single ' quote ""#]; for input in inputs { - assert_borrowed_token(input, quote, false) + assert_borrowed_token(input, quote, AsToken::String, SourceFileKind::JavaScript) } } @@ -584,7 +647,13 @@ mod string_literal_tests { (r#"" content \\' \" ""#, r#"" content \\' \" ""#), ]; for (input, output) in inputs { - assert_owned_token(input, output, quote, false) + assert_owned_token( + input, + output, + quote, + AsToken::String, + SourceFileKind::JavaScript, + ) } } @@ -593,7 +662,7 @@ mod string_literal_tests { let quote = QuoteStyle::Double; let inputs = [r#""use strict '""#]; for input in inputs { - assert_borrowed_token(input, quote, false) + assert_borrowed_token(input, quote, AsToken::Directive, SourceFileKind::JavaScript) } } @@ -602,7 +671,37 @@ mod string_literal_tests { let quote = QuoteStyle::Double; let inputs = [(r#"' use strict '"#, r#"" use strict ""#)]; for (input, output) in inputs { - assert_owned_token(input, output, quote, false) + assert_owned_token( + input, + output, + quote, + AsToken::Directive, + SourceFileKind::JavaScript, + ) + } + } + + #[test] + fn member_borrowed() { + let quote = QuoteStyle::Double; + let inputs = [r#""cant @ be moved""#, r#""1674""#, r#""33n""#]; + for input in inputs { + assert_borrowed_token(input, quote, AsToken::Member, SourceFileKind::TypeScript) + } + } + + #[test] + fn member_owned() { + let quote = QuoteStyle::Double; + let inputs = [(r#""string""#, r#"string"#)]; + for (input, output) in inputs { + assert_owned_token( + input, + output, + quote, + AsToken::Member, + SourceFileKind::TypeScript, + ) } } } diff --git a/crates/rome_js_formatter/tests/specs/js/module/object/object_comments.js.snap b/crates/rome_js_formatter/tests/specs/js/module/object/object_comments.js.snap index cd705fa79ae..bc8e0771738 100644 --- a/crates/rome_js_formatter/tests/specs/js/module/object/object_comments.js.snap +++ b/crates/rome_js_formatter/tests/specs/js/module/object/object_comments.js.snap @@ -1,5 +1,6 @@ --- source: crates/rome_js_formatter/tests/spec_test.rs +assertion_line: 257 expression: object_comments.js --- # Input @@ -17,7 +18,7 @@ Quote style: Double Quotes ----- let a = { // leading comment - "type": "bar", + type: "bar", // trailing comment }; diff --git a/crates/rome_js_formatter/tests/specs/js/module/object/property_key.js.snap b/crates/rome_js_formatter/tests/specs/js/module/object/property_key.js.snap index 3c448632dc2..53babcb1ed5 100644 --- a/crates/rome_js_formatter/tests/specs/js/module/object/property_key.js.snap +++ b/crates/rome_js_formatter/tests/specs/js/module/object/property_key.js.snap @@ -1,5 +1,6 @@ --- source: crates/rome_js_formatter/tests/spec_test.rs +assertion_line: 257 expression: property_key.js --- # Input @@ -22,8 +23,8 @@ Quote style: Double Quotes ----- const foo = { "foo-bar": true, - "bar": { - "lorem_ispsum": { + bar: { + lorem_ispsum: { "lorem-ipsum": true, }, }, diff --git a/crates/rome_js_formatter/tests/specs/js/module/string/properties_quotes.js b/crates/rome_js_formatter/tests/specs/js/module/string/properties_quotes.js new file mode 100644 index 00000000000..1e6d51521bb --- /dev/null +++ b/crates/rome_js_formatter/tests/specs/js/module/string/properties_quotes.js @@ -0,0 +1,38 @@ +class Y { + "other" = 4; + "method"() {} + "another_method"() {} + "camelMethod"() {} + "stay-like-this"() {} + get "getter"() {} + set "setterr"(value) {} + "constructor"() {} +} + +let value = { "a": "test", "quotes-required": "test" }; + +({ "a": test } = value); + +let { "a": test } = value; + +// you guys stay like this + +({ "$$_": test } = value); + +({ "%{}": test } = value); + +({ "[]": test } = value); + +let { "fff--fff": test } = value; + +let { "with_underscore": test } = value; + +let a = { "": 10, "c_d": 30 } + +let b = { "'": 10, "c_d": 30 } + +let { "_$_ff$_morning_not_quotes": test, "_$_ff$_morning_yes_quotes_@": test } = value; + +let { "_$_$_%": test } = value; + +let { "0197": test, "3n": test, "3p": test, "p9": test } = value; diff --git a/crates/rome_js_formatter/tests/specs/js/module/string/properties_quotes.js.snap b/crates/rome_js_formatter/tests/specs/js/module/string/properties_quotes.js.snap new file mode 100644 index 00000000000..cce054af3e5 --- /dev/null +++ b/crates/rome_js_formatter/tests/specs/js/module/string/properties_quotes.js.snap @@ -0,0 +1,142 @@ +--- +source: crates/rome_js_formatter/tests/spec_test.rs +assertion_line: 257 +expression: properties_quotes.js +--- +# Input +class Y { + "other" = 4; + "method"() {} + "another_method"() {} + "camelMethod"() {} + "stay-like-this"() {} + get "getter"() {} + set "setterr"(value) {} + "constructor"() {} +} + +let value = { "a": "test", "quotes-required": "test" }; + +({ "a": test } = value); + +let { "a": test } = value; + +// you guys stay like this + +({ "$$_": test } = value); + +({ "%{}": test } = value); + +({ "[]": test } = value); + +let { "fff--fff": test } = value; + +let { "with_underscore": test } = value; + +let a = { "": 10, "c_d": 30 } + +let b = { "'": 10, "c_d": 30 } + +let { "_$_ff$_morning_not_quotes": test, "_$_ff$_morning_yes_quotes_@": test } = value; + +let { "_$_$_%": test } = value; + +let { "0197": test, "3n": test, "3p": test, "p9": test } = value; + +============================= +# Outputs +## Output 1 +----- +Indent style: Tab +Line width: 80 +Quote style: Double Quotes +----- +class Y { + other = 4; + method() {} + another_method() {} + camelMethod() {} + "stay-like-this"() {} + get getter() {} + set setterr(value) {} + constructor() {} +} + +let value = { a: "test", "quotes-required": "test" }; + +({ a: test } = value); + +let { a: test } = value; + +// you guys stay like this + +({ $$_: test } = value); + +({ "%{}": test } = value); + +({ "[]": test } = value); + +let { "fff--fff": test } = value; + +let { with_underscore: test } = value; + +let a = { "": 10, c_d: 30 }; + +let b = { "'": 10, c_d: 30 }; + +let { + _$_ff$_morning_not_quotes: test, + "_$_ff$_morning_yes_quotes_@": test, +} = value; + +let { "_$_$_%": test } = value; + +let { 0197: test, "3n": test, "3p": test, p9: test } = value; +## Output 2 +----- +Indent style: Tab +Line width: 80 +Quote style: Single Quotes +----- +class Y { + other = 4; + method() {} + another_method() {} + camelMethod() {} + 'stay-like-this'() {} + get getter() {} + set setterr(value) {} + constructor() {} +} + +let value = { a: 'test', 'quotes-required': 'test' }; + +({ a: test } = value); + +let { a: test } = value; + +// you guys stay like this + +({ $$_: test } = value); + +({ '%{}': test } = value); + +({ '[]': test } = value); + +let { 'fff--fff': test } = value; + +let { with_underscore: test } = value; + +let a = { '': 10, c_d: 30 }; + +let b = { "'": 10, c_d: 30 }; + +let { + _$_ff$_morning_not_quotes: test, + '_$_ff$_morning_yes_quotes_@': test, +} = value; + +let { '_$_$_%': test } = value; + +let { 0197: test, '3n': test, '3p': test, p9: test } = value; + diff --git a/crates/rome_js_formatter/tests/specs/js/module/string/string.js.snap b/crates/rome_js_formatter/tests/specs/js/module/string/string.js.snap index 4741e4dcea4..5b72dbc57de 100644 --- a/crates/rome_js_formatter/tests/specs/js/module/string/string.js.snap +++ b/crates/rome_js_formatter/tests/specs/js/module/string/string.js.snap @@ -1,6 +1,6 @@ --- source: crates/rome_js_formatter/tests/spec_test.rs -assertion_line: 244 +assertion_line: 257 expression: string.js --- # Input @@ -94,7 +94,7 @@ c?.[d]; let a = { // leading comment - "type": "bar", + type: "bar", // trailing comment }; @@ -168,7 +168,7 @@ c?.[d]; let a = { // leading comment - 'type': 'bar', + type: 'bar', // trailing comment }; diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/assignment/issue-7572.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/assignment/issue-7572.js.snap index 121d53c1ca8..48812cf972e 100644 --- a/crates/rome_js_formatter/tests/specs/prettier/js/assignment/issue-7572.js.snap +++ b/crates/rome_js_formatter/tests/specs/prettier/js/assignment/issue-7572.js.snap @@ -1,5 +1,6 @@ --- source: crates/rome_js_formatter/tests/prettier_tests.rs +assertion_line: 182 expression: issue-7572.js --- # Input @@ -16,7 +17,7 @@ const t = { # Output ```js const t = { - "hello": world(), + hello: world(), "this-is-a-very-long-key-and-the-assignment-should-be-put-on-the-next-line": orMaybeIAmMisunderstandingAndIHaveSetSomethingWrongInMyConfig(), "can-someone-explain": this(), }; diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/object-prop-break-in/long-value.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/object-prop-break-in/long-value.js.snap index ef976244f7e..c7723516620 100644 --- a/crates/rome_js_formatter/tests/specs/prettier/js/object-prop-break-in/long-value.js.snap +++ b/crates/rome_js_formatter/tests/specs/prettier/js/object-prop-break-in/long-value.js.snap @@ -1,5 +1,6 @@ --- source: crates/rome_js_formatter/tests/prettier_tests.rs +assertion_line: 182 expression: long-value.js --- # Input @@ -13,13 +14,13 @@ const x = { # Output ```js const x = { - "ABC": "12345678901234567890123456789012345678901234567890123456789012345678901234567890", + ABC: "12345678901234567890123456789012345678901234567890123456789012345678901234567890", }; ``` # Lines exceeding max width of 80 characters ``` - 2: "ABC": "12345678901234567890123456789012345678901234567890123456789012345678901234567890", + 2: ABC: "12345678901234567890123456789012345678901234567890123456789012345678901234567890", ``` diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/object-prop-break-in/short-keys.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/object-prop-break-in/short-keys.js.snap index 8a91a25ec8d..d1c6176568b 100644 --- a/crates/rome_js_formatter/tests/specs/prettier/js/object-prop-break-in/short-keys.js.snap +++ b/crates/rome_js_formatter/tests/specs/prettier/js/object-prop-break-in/short-keys.js.snap @@ -1,5 +1,6 @@ --- source: crates/rome_js_formatter/tests/prettier_tests.rs +assertion_line: 182 expression: short-keys.js --- # Input @@ -34,16 +35,16 @@ var obj = { longName: "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890", [i]: "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890", [prop]: "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890", - "x": "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890", + x: "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890", a: "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890", ab: "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890", abc: "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890", abcd: "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890", abcde: "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890", abcdef: "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890", - "古": "https://prettier.io/docs/en/rationale.html#what-prettier-is-concerned-about", - "古今": "https://prettier.io/docs/en/rationale.html#what-prettier-is-concerned-about", - "古体诗": "https://prettier.io/docs/en/rationale.html#what-prettier-is-concerned-about", + 古: "https://prettier.io/docs/en/rationale.html#what-prettier-is-concerned-about", + 古今: "https://prettier.io/docs/en/rationale.html#what-prettier-is-concerned-about", + 古体诗: "https://prettier.io/docs/en/rationale.html#what-prettier-is-concerned-about", }; ``` @@ -55,15 +56,15 @@ var obj = { 5: longName: "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890", 6: [i]: "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890", 7: [prop]: "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890", - 8: "x": "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890", + 8: x: "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890", 9: a: "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890", 10: ab: "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890", 11: abc: "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890", 12: abcd: "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890", 13: abcde: "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890", 14: abcdef: "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890", - 15: "古": "https://prettier.io/docs/en/rationale.html#what-prettier-is-concerned-about", - 16: "古今": "https://prettier.io/docs/en/rationale.html#what-prettier-is-concerned-about", - 17: "古体诗": "https://prettier.io/docs/en/rationale.html#what-prettier-is-concerned-about", + 15: 古: "https://prettier.io/docs/en/rationale.html#what-prettier-is-concerned-about", + 16: 古今: "https://prettier.io/docs/en/rationale.html#what-prettier-is-concerned-about", + 17: 古体诗: "https://prettier.io/docs/en/rationale.html#what-prettier-is-concerned-about", ``` diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/object-property-comment/after-key.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/object-property-comment/after-key.js.snap index 7558081b827..429373d986b 100644 --- a/crates/rome_js_formatter/tests/specs/prettier/js/object-property-comment/after-key.js.snap +++ b/crates/rome_js_formatter/tests/specs/prettier/js/object-property-comment/after-key.js.snap @@ -1,5 +1,6 @@ --- source: crates/rome_js_formatter/tests/prettier_tests.rs +assertion_line: 182 expression: after-key.js --- # Input @@ -21,7 +22,7 @@ let a = { }; let b = { - "a" /* comment */ : () => 1, + a /* comment */ : () => 1, }; ``` diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/quotes/objects.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/quotes/objects.js.snap index 3cb880e51c9..5683b68565e 100644 --- a/crates/rome_js_formatter/tests/specs/prettier/js/quotes/objects.js.snap +++ b/crates/rome_js_formatter/tests/specs/prettier/js/quotes/objects.js.snap @@ -1,5 +1,6 @@ --- source: crates/rome_js_formatter/tests/prettier_tests.rs +assertion_line: 182 expression: objects.js --- # Input @@ -15,9 +16,9 @@ const obj = { # Output ```js const obj = { - "a": true, + a: true, b: true, - "𐊧": true, + 𐊧: true, }; ``` diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/unicode/keys.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/unicode/keys.js.snap index d10f0f32c7b..38740044b95 100644 --- a/crates/rome_js_formatter/tests/specs/prettier/js/unicode/keys.js.snap +++ b/crates/rome_js_formatter/tests/specs/prettier/js/unicode/keys.js.snap @@ -1,5 +1,6 @@ --- source: crates/rome_js_formatter/tests/prettier_tests.rs +assertion_line: 182 expression: keys.js --- # Input @@ -10,7 +11,7 @@ expression: keys.js # Output ```js -({ "この事はつもり素晴らしいことさ": "35jL9V" }); +({ この事はつもり素晴らしいことさ: "35jL9V" }); ``` diff --git a/crates/rome_js_formatter/tests/specs/prettier/typescript/class/quoted-property.ts.snap b/crates/rome_js_formatter/tests/specs/prettier/typescript/class/quoted-property.ts.snap index dfeff2afd47..c12f7673653 100644 --- a/crates/rome_js_formatter/tests/specs/prettier/typescript/class/quoted-property.ts.snap +++ b/crates/rome_js_formatter/tests/specs/prettier/typescript/class/quoted-property.ts.snap @@ -1,8 +1,7 @@ --- source: crates/rome_js_formatter/tests/prettier_tests.rs -assertion_line: 123 +assertion_line: 182 expression: quoted-property.ts - --- # Input ```js @@ -15,7 +14,7 @@ class User { # Output ```js class User { - "username": string; + username: string; } ``` diff --git a/crates/rome_js_formatter/tests/specs/prettier/typescript/compiler/ClassDeclaration22.ts.snap b/crates/rome_js_formatter/tests/specs/prettier/typescript/compiler/ClassDeclaration22.ts.snap index 9cbf0b450aa..09cd4713a3d 100644 --- a/crates/rome_js_formatter/tests/specs/prettier/typescript/compiler/ClassDeclaration22.ts.snap +++ b/crates/rome_js_formatter/tests/specs/prettier/typescript/compiler/ClassDeclaration22.ts.snap @@ -1,8 +1,7 @@ --- source: crates/rome_js_formatter/tests/prettier_tests.rs -assertion_line: 125 +assertion_line: 182 expression: ClassDeclaration22.ts - --- # Input ```js @@ -16,8 +15,8 @@ class C { # Output ```js class C { - "foo"(); - "bar"() {} + foo(); + bar() {} } ``` diff --git a/crates/rome_js_formatter/tests/specs/prettier/typescript/custom/computedProperties/string.ts.snap b/crates/rome_js_formatter/tests/specs/prettier/typescript/custom/computedProperties/string.ts.snap index 5b0fa806add..2740b50064e 100644 --- a/crates/rome_js_formatter/tests/specs/prettier/typescript/custom/computedProperties/string.ts.snap +++ b/crates/rome_js_formatter/tests/specs/prettier/typescript/custom/computedProperties/string.ts.snap @@ -26,19 +26,19 @@ type B = { # Output ```js interface I { - "string": "I"; + string: "I"; } type T = { - "string": "T"; + string: "T"; }; interface A { - "string": "A"; + string: "A"; } type B = { - "string": "B"; + string: "B"; }; ``` diff --git a/crates/rome_js_formatter/tests/specs/ts/string/options.json b/crates/rome_js_formatter/tests/specs/ts/string/options.json new file mode 100644 index 00000000000..e0f19f511b0 --- /dev/null +++ b/crates/rome_js_formatter/tests/specs/ts/string/options.json @@ -0,0 +1,7 @@ +{ + "cases": [ + { + "quote_style": "Single" + } + ] +} diff --git a/crates/rome_js_formatter/tests/specs/ts/string/parameter_quotes.ts b/crates/rome_js_formatter/tests/specs/ts/string/parameter_quotes.ts new file mode 100644 index 00000000000..3b5cd23d4f1 --- /dev/null +++ b/crates/rome_js_formatter/tests/specs/ts/string/parameter_quotes.ts @@ -0,0 +1,36 @@ +import * as f from "f"; + +type X = { + "member": string; + // you stay like this + "member-member": number, + "4": number, + "with_underscore": number + "0197": number, + "3n": number, + "3p": number, + "p9": number + "_$_ff$_morning_not_quotes": number, + "_$_ff$_morning_yes_quotes_@": number +}; + + +interface Y { + "member": string; + // you stay like this + "member-member": number, + "4": number, + "with_underscore": number + "0197": number, + "3n": number, + "3p": number, + "p9": number + "_$_ff$_morning_not_quotes": number, + "_$_ff$_morning_yes_quotes_@": number +} + +const Y = { + "123": false, + "3n": false, + 12334: false +} \ No newline at end of file diff --git a/crates/rome_js_formatter/tests/specs/ts/string/parameter_quotes.ts.snap b/crates/rome_js_formatter/tests/specs/ts/string/parameter_quotes.ts.snap new file mode 100644 index 00000000000..c4a71046cb3 --- /dev/null +++ b/crates/rome_js_formatter/tests/specs/ts/string/parameter_quotes.ts.snap @@ -0,0 +1,127 @@ +--- +source: crates/rome_js_formatter/tests/spec_test.rs +assertion_line: 257 +expression: parameter_quotes.ts +--- +# Input +import * as f from "f"; + +type X = { + "member": string; + // you stay like this + "member-member": number, + "4": number, + "with_underscore": number + "0197": number, + "3n": number, + "3p": number, + "p9": number + "_$_ff$_morning_not_quotes": number, + "_$_ff$_morning_yes_quotes_@": number +}; + + +interface Y { + "member": string; + // you stay like this + "member-member": number, + "4": number, + "with_underscore": number + "0197": number, + "3n": number, + "3p": number, + "p9": number + "_$_ff$_morning_not_quotes": number, + "_$_ff$_morning_yes_quotes_@": number +} + +const Y = { + "123": false, + "3n": false, + 12334: false +} +============================= +# Outputs +## Output 1 +----- +Indent style: Tab +Line width: 80 +Quote style: Double Quotes +----- +import * as f from "f"; + +type X = { + member: string; + // you stay like this + "member-member": number; + 4: number; + with_underscore: number; + 0197: number; + "3n": number; + "3p": number; + p9: number; + _$_ff$_morning_not_quotes: number; + "_$_ff$_morning_yes_quotes_@": number; +}; + +interface Y { + member: string; + // you stay like this + "member-member": number; + 4: number; + with_underscore: number; + 0197: number; + "3n": number; + "3p": number; + p9: number; + _$_ff$_morning_not_quotes: number; + "_$_ff$_morning_yes_quotes_@": number; +} + +const Y = { + 123: false, + "3n": false, + 12334: false, +}; +## Output 2 +----- +Indent style: Tab +Line width: 80 +Quote style: Single Quotes +----- +import * as f from 'f'; + +type X = { + member: string; + // you stay like this + 'member-member': number; + '4': number; + with_underscore: number; + '0197': number; + '3n': number; + '3p': number; + p9: number; + _$_ff$_morning_not_quotes: number; + '_$_ff$_morning_yes_quotes_@': number; +}; + +interface Y { + member: string; + // you stay like this + 'member-member': number; + '4': number; + with_underscore: number; + '0197': number; + '3n': number; + '3p': number; + p9: number; + _$_ff$_morning_not_quotes: number; + '_$_ff$_morning_yes_quotes_@': number; +} + +const Y = { + '123': false, + '3n': false, + 12334: false, +}; + diff --git a/crates/rome_js_semantic/src/events.rs b/crates/rome_js_semantic/src/events.rs index ed9ec8f0b5c..cf039c1fd99 100644 --- a/crates/rome_js_semantic/src/events.rs +++ b/crates/rome_js_semantic/src/events.rs @@ -2,7 +2,7 @@ use std::collections::VecDeque; -use rome_js_syntax::{JsLanguage, JsSyntaxNode, TextRange}; +use rome_js_syntax::{JsLanguage, JsSyntaxNode, TextRange, TextSize}; use rome_rowan::syntax::Preorder; /// Events emitted by the [SemanticEventExtractor]. These events are later @@ -15,12 +15,29 @@ pub enum SemanticEvent { /// - Import bindings /// - Functions parameters DeclarationFound { range: TextRange }, + + /// Signifies that a new scope was started + /// Currently generated for: + /// - Blocks + /// - Function body + ScopeStarted { range: TextRange }, + + /// Signifies that a new scope was ended + /// Currently generated for: + /// - Blocks + /// - Function body + ScopeEnded { + range: TextRange, + started_at: TextSize, + }, } impl SemanticEvent { pub fn range(&self) -> &TextRange { match self { SemanticEvent::DeclarationFound { range } => range, + SemanticEvent::ScopeStarted { range } => range, + SemanticEvent::ScopeEnded { range, .. } => range, } } @@ -53,9 +70,8 @@ impl SemanticEvent { /// let mut extractor = SemanticEventExtractor::new(); /// for e in tree.syntax().preorder() { /// match e { -/// WalkEvent::Enter(node) => { -/// extractor.extract_from(&node); -/// } +/// WalkEvent::Enter(node) => extractor.enter(&node), +/// WalkEvent::Leave(node) => extractor.leave(&node), /// _ => {} /// } /// @@ -67,24 +83,44 @@ impl SemanticEvent { #[derive(Default)] pub struct SemanticEventExtractor { stash: VecDeque, + scopes: Vec, +} + +struct Scope { + started_at: TextSize, } impl SemanticEventExtractor { pub fn new() -> Self { Self { stash: VecDeque::new(), + scopes: vec![], } } /// See [SemanticEvent] for a more detailed description - /// of which ```SyntaxNode``` generated which events. - pub fn extract_from(&mut self, node: &JsSyntaxNode) { + /// of which ```SyntaxNode``` generates which events. + pub fn enter(&mut self, node: &JsSyntaxNode) { use rome_js_syntax::JsSyntaxKind::*; use SemanticEvent::*; - if let JS_IDENTIFIER_BINDING = node.kind() { - self.stash.push_back(DeclarationFound { + + match node.kind() { + JS_IDENTIFIER_BINDING => self.stash.push_back(DeclarationFound { range: node.text_range(), - }) + }), + JS_BLOCK_STATEMENT | JS_FUNCTION_BODY => self.push_scope(node.text_range()), + _ => {} + } + } + + /// See [SemanticEvent] for a more detailed description + /// of which ```SyntaxNode``` generates which events. + pub fn leave(&mut self, node: &JsSyntaxNode) { + use rome_js_syntax::JsSyntaxKind::*; + + match node.kind() { + JS_BLOCK_STATEMENT | JS_FUNCTION_BODY => self.pop_scope(node.text_range()), + _ => {} } } @@ -92,6 +128,22 @@ impl SemanticEventExtractor { pub fn pop(&mut self) -> Option { self.stash.pop_front() } + + fn push_scope(&mut self, range: TextRange) { + self.stash.push_back(SemanticEvent::ScopeStarted { range }); + self.scopes.push(Scope { + started_at: range.start(), + }); + } + + fn pop_scope(&mut self, range: TextRange) { + if let Some(scope) = self.scopes.pop() { + self.stash.push_back(SemanticEvent::ScopeEnded { + range, + started_at: scope.started_at, + }); + } + } } /// Extracts [SemanticEvent] from [SyntaxNode]. @@ -112,10 +164,18 @@ impl Iterator for SemanticEventIterator { use rome_js_syntax::WalkEvent::*; match self.iter.next() { Some(Enter(node)) => { - self.extractor.extract_from(&node); + self.extractor.enter(&node); + } + Some(Leave(node)) => { + self.extractor.leave(&node); + } + None => { + if let Some(e) = self.extractor.pop() { + break Some(e); + } else { + break None; + } } - Some(_) => {} - None => break None, } } } diff --git a/crates/rome_js_semantic/src/tests.rs b/crates/rome_js_semantic/src/tests/events.rs similarity index 93% rename from crates/rome_js_semantic/src/tests.rs rename to crates/rome_js_semantic/src/tests/events.rs index 47c6d1bce9a..e43cea7b935 100644 --- a/crates/rome_js_semantic/src/tests.rs +++ b/crates/rome_js_semantic/src/tests/events.rs @@ -1,6 +1,8 @@ use std::collections::{BTreeMap, HashMap}; -use super::*; +use crate::semantic_events; +use crate::SemanticEvent; + use rome_console::{ConsoleExt, EnvConsole}; use rome_diagnostics::{file::SimpleFile, Applicability, Diagnostic}; use rome_js_syntax::JsSyntaxToken; @@ -62,10 +64,8 @@ fn assert(code: &str) { let mut event_by_range = HashMap::new(); for event in semantic_events(r.syntax()) { - match &event { - SemanticEvent::DeclarationFound { range, .. } => { - event_by_range.insert(*range, event); - } + if let SemanticEvent::DeclarationFound { range, .. } = &event { + event_by_range.insert(*range, event); } } @@ -92,6 +92,9 @@ fn assert(code: &str) { SemanticEvent::DeclarationFound { .. } => { // No need to check anything on declarations } + _ => { + error_declaration_assertion_not_attached_to_a_declaration(code, assertion_range) + } } } else { error_declaration_assertion_not_attached_to_a_declaration(code, assertion_range); diff --git a/crates/rome_js_semantic/src/tests/mod.rs b/crates/rome_js_semantic/src/tests/mod.rs new file mode 100644 index 00000000000..40c3b6bf74c --- /dev/null +++ b/crates/rome_js_semantic/src/tests/mod.rs @@ -0,0 +1,2 @@ +pub mod events; +pub mod scopes; diff --git a/crates/rome_js_semantic/src/tests/scopes.rs b/crates/rome_js_semantic/src/tests/scopes.rs new file mode 100644 index 00000000000..6022fcade4d --- /dev/null +++ b/crates/rome_js_semantic/src/tests/scopes.rs @@ -0,0 +1,312 @@ +use std::collections::{BTreeMap, HashMap}; + +use crate::{semantic_events, SemanticEvent}; +use rome_console::{markup, ConsoleExt, EnvConsole}; +use rome_diagnostics::{file::SimpleFile, Applicability, Diagnostic, Severity}; +use rome_js_syntax::{JsSyntaxToken, SourceType, TextRange, TextSize, WalkEvent}; +use rome_rowan::NodeOrToken; + +#[test] +pub fn ok_scope_blocks() { + assert("if (true) {/*START A*/ }/*END A*/"); + assert("function f() {/*START A*/ }/*END A*/"); + assert("for (const a of []) {/*START A*/ }/*END A*/"); + assert("for (const a in []) {/*START A*/ }/*END A*/"); + assert("() => {/*START A*/ }/*END A*/"); + + assert("class A { constructor () {/*START A*/ }/*END A*/ }"); + assert("class A { get name() {/*START A*/ }/*END A*/ }"); + assert("class A { set name(v) {/*START A*/ }/*END A*/ }"); + + assert("try {/*START A*/ }/*END A*/ catch(e) {/*START B*/ }/*END B*/ finally {/*START C*/ }/*END C*/"); +} + +/// This method helps testing scope resolution. It does this +/// iterating [SemanticEventIterator] and storing where each scope start and end. Later it iterates +/// the tree looking at tokens with trailing comments following a specifically patterns +/// specifying if a scope has started or ended. +/// +/// ### Available Patterns +/// +/// #### Scope Start Assertion +/// +/// Test if the attached token starts a new scope. +/// Pattern: ```/*START