From 7ff14a941a40ee32146ce96cc38b3fd920ab0781 Mon Sep 17 00:00:00 2001
From: Micha Reiser <micha@rome.tools>
Date: Thu, 15 Sep 2022 11:29:08 +0200
Subject: [PATCH 01/15] Empty File to create placeholder PR

---
 empty.txt | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 empty.txt

diff --git a/empty.txt b/empty.txt
new file mode 100644
index 00000000000..e69de29bb2d

From 9977d282e7b4a12210febd052869bfa64d6ef6bb Mon Sep 17 00:00:00 2001
From: Micha Reiser <micha@rome.tools>
Date: Thu, 15 Sep 2022 14:26:55 +0200
Subject: [PATCH 02/15] Empty File to create placeholder PR

---
 empty.txt | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 delete mode 100644 empty.txt

diff --git a/empty.txt b/empty.txt
deleted file mode 100644
index e69de29bb2d..00000000000

From 8c0ee68e6a16993a99b528e8490fa0c6bec8e4c9 Mon Sep 17 00:00:00 2001
From: Micha Reiser <micha@rome.tools>
Date: Fri, 16 Sep 2022 14:32:47 +0200
Subject: [PATCH 03/15] feat(rome_formatter): Comments multi map (#3230)

---
 Cargo.lock                                |   1 +
 crates/rome_formatter/Cargo.toml          |   1 +
 crates/rome_formatter/src/comments.rs     |   2 +
 crates/rome_formatter/src/comments/map.rs | 820 ++++++++++++++++++++++
 4 files changed, 824 insertions(+)
 create mode 100644 crates/rome_formatter/src/comments/map.rs

diff --git a/Cargo.lock b/Cargo.lock
index 33069cdfa8d..646804faacb 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1585,6 +1585,7 @@ name = "rome_formatter"
 version = "0.0.0"
 dependencies = [
  "cfg-if",
+ "countme",
  "indexmap",
  "rome_rowan",
  "rustc-hash",
diff --git a/crates/rome_formatter/Cargo.toml b/crates/rome_formatter/Cargo.toml
index c288a1f6035..fde1f730112 100644
--- a/crates/rome_formatter/Cargo.toml
+++ b/crates/rome_formatter/Cargo.toml
@@ -16,6 +16,7 @@ cfg-if = "1.0.0"
 indexmap = "1.8.2"
 schemars = { version = "0.8.10", optional = true }
 rustc-hash = "1.1.0"
+countme = "3.0.1"
 
 [features]
 serde = ["dep:serde", "schemars", "rome_rowan/serde"]
diff --git a/crates/rome_formatter/src/comments.rs b/crates/rome_formatter/src/comments.rs
index d6c34cad742..4c53a59b443 100644
--- a/crates/rome_formatter/src/comments.rs
+++ b/crates/rome_formatter/src/comments.rs
@@ -1,3 +1,5 @@
+mod map;
+
 use rome_rowan::{
     Direction, Language, SyntaxElement, SyntaxKind, SyntaxNode, SyntaxTriviaPieceComments,
     WalkEvent,
diff --git a/crates/rome_formatter/src/comments/map.rs b/crates/rome_formatter/src/comments/map.rs
new file mode 100644
index 00000000000..a60e2d32ad5
--- /dev/null
+++ b/crates/rome_formatter/src/comments/map.rs
@@ -0,0 +1,820 @@
+use countme::Count;
+use rustc_hash::FxHashMap;
+use std::fmt::{Debug, Formatter};
+use std::iter::FusedIterator;
+use std::num::NonZeroU32;
+use std::ops::Range;
+
+/// An optimized multi-map implementation for storing leading, dangling, and trailing parts for a key.
+///
+/// A naive implementation using three multimaps, one to store the leading, dangling, and trailing parts,
+/// requires between `keys < allocations < keys * 3` vec allocations.
+///
+/// This map implementation optimises for the use case where:
+/// * Parts belonging to the same key are inserted together. For example, all parts for the key `a` are inserted
+///   before inserting any parts for the key `b`.
+/// * The parts per key are inserted in the following order: leading, dangling, and then trailing parts.
+///
+/// Parts inserted in the above mentioned order are stored in a `Vec` shared by all keys to reduce the number
+/// of allocations and increased cache locality. The implementation falls back to
+/// storing the leading, dangling, and trailing parts of a key in dedicated `Vec`s if the parts
+/// aren't inserted in the above described order. However, this comes with a slight performance penalty due to:
+/// * Requiring up to three [Vec] allocations, one for the leading, dangling, and trailing parts.
+/// * Requires copying already inserted parts for that key (by cloning) into the newly allocated [Vec]s.
+/// * Resolving the slices for every part requires an extra level of indirection.
+///
+/// ## Limitations
+///
+/// The map supports storing up to `u32::MAX - 1` parts. Inserting the `u32::MAX`nth part panics.
+///
+/// ## Comments
+///
+/// Storing the leading, dangling, and trailing comments is an exemplary use case for this map implementation because
+/// it is generally desired to keep the comments in the same order as in the source document. This translates to
+/// inserting the comments per node and for every node in leading, dangling, trailing order (same order as this map optimises for).
+///
+/// Running Rome formatter on real world use cases showed that more than 99.99% of comments get inserted in
+/// the described order.
+///
+/// The size limitation isn't a concern for comments because Rome supports source documents with a size up to 4GB (`u32::MAX`)
+/// and every comment has at least a size of 2 bytes:
+/// * 1 byte for the start sequence, e.g. `#`
+/// * 1 byte for the end sequence, e.g. `\n`
+///
+/// Meaning, the upper bound for comments parts in a document are `u32::MAX / 2`.
+pub(super) struct CommentsMap<K, V> {
+    /// Lookup table to retrieve the entry for a key.
+    index: FxHashMap<K, Entry>,
+
+    /// Flat array storing all the parts that have been inserted in order.
+    parts: Vec<V>,
+
+    /// Vector containing the leading, dangling, and trailing vectors for out of order entries.
+    ///
+    /// The length of `out_of_order` is a multiple of 3 where:
+    /// * `index % 3 == 0`: Leading parts
+    /// * `index % 3 == 1`: Dangling parts
+    /// * `index % 3 == 2`: Trailing parts
+    out_of_order: Vec<Vec<V>>,
+}
+
+impl<K: std::hash::Hash + Eq, V> CommentsMap<K, V> {
+    pub fn new() -> Self {
+        Self {
+            index: FxHashMap::default(),
+            parts: Vec::new(),
+            out_of_order: Vec::new(),
+        }
+    }
+
+    /// Pushes a leading part for `key`.
+    pub fn push_leading(&mut self, key: K, part: V)
+    where
+        V: Clone,
+    {
+        match self.index.get_mut(&key) {
+            None => {
+                let start = self.parts.len();
+                self.parts.push(part);
+
+                self.index.insert(
+                    key,
+                    Entry::InOrder(InOrderEntry::leading(start..self.parts.len())),
+                );
+            }
+
+            // Has only leading comments and no elements have been pushed since
+            Some(Entry::InOrder(entry))
+                if entry.trailing_start.is_none() && self.parts.len() == entry.range().end =>
+            {
+                self.parts.push(part);
+                entry.increment_leading_range();
+            }
+
+            Some(Entry::OutOfOrder(entry)) => {
+                let leading = &mut self.out_of_order[entry.leading_index()];
+                leading.push(part);
+            }
+
+            Some(entry) => {
+                let out_of_order =
+                    Self::entry_to_out_of_order(entry, &self.parts, &mut self.out_of_order);
+                self.out_of_order[out_of_order.leading_index()].push(part);
+            }
+        }
+    }
+
+    /// Pushes a dangling part for `key`
+    pub fn push_dangling(&mut self, key: K, part: V)
+    where
+        V: Clone,
+    {
+        match self.index.get_mut(&key) {
+            None => {
+                let start = self.parts.len();
+                self.parts.push(part);
+
+                self.index.insert(
+                    key,
+                    Entry::InOrder(InOrderEntry::dangling(start..self.parts.len())),
+                );
+            }
+
+            // Has leading and dangling comments and its comments are at the end of parts
+            Some(Entry::InOrder(entry))
+                if entry.trailing_end.is_none() && self.parts.len() == entry.range().end =>
+            {
+                self.parts.push(part);
+                entry.increment_dangling_range();
+            }
+
+            Some(Entry::OutOfOrder(entry)) => {
+                let dangling = &mut self.out_of_order[entry.dangling_index()];
+                dangling.push(part);
+            }
+
+            Some(entry) => {
+                let out_of_order =
+                    Self::entry_to_out_of_order(entry, &self.parts, &mut self.out_of_order);
+                self.out_of_order[out_of_order.dangling_index()].push(part);
+            }
+        }
+    }
+
+    /// Pushes a trailing part for `key`.
+    pub fn push_trailing(&mut self, key: K, part: V)
+    where
+        V: Clone,
+    {
+        match self.index.get_mut(&key) {
+            None => {
+                let start = self.parts.len();
+                self.parts.push(part);
+
+                self.index.insert(
+                    key,
+                    Entry::InOrder(InOrderEntry::trailing(start..self.parts.len())),
+                );
+            }
+
+            // Its comments are at the end
+            Some(Entry::InOrder(entry)) if entry.range().end == self.parts.len() => {
+                self.parts.push(part);
+                entry.increment_trailing_range();
+            }
+
+            Some(Entry::OutOfOrder(entry)) => {
+                let trailing = &mut self.out_of_order[entry.trailing_index()];
+                trailing.push(part);
+            }
+
+            Some(entry) => {
+                let out_of_order =
+                    Self::entry_to_out_of_order(entry, &self.parts, &mut self.out_of_order);
+                self.out_of_order[out_of_order.trailing_index()].push(part);
+            }
+        }
+    }
+
+    #[cold]
+    fn entry_to_out_of_order<'a>(
+        entry: &'a mut Entry,
+        parts: &[V],
+        out_of_order: &mut Vec<Vec<V>>,
+    ) -> &'a mut OutOfOrderEntry
+    where
+        V: Clone,
+    {
+        match entry {
+            Entry::InOrder(in_order) => {
+                let index = out_of_order.len();
+
+                out_of_order.push(parts[in_order.leading_range()].to_vec());
+                out_of_order.push(parts[in_order.dangling_range()].to_vec());
+                out_of_order.push(parts[in_order.trailing_range()].to_vec());
+
+                *entry = Entry::OutOfOrder(OutOfOrderEntry {
+                    leading_index: index,
+                    _count: Count::new(),
+                });
+
+                match entry {
+                    Entry::InOrder(_) => unreachable!(),
+                    Entry::OutOfOrder(out_of_order) => out_of_order,
+                }
+            }
+            Entry::OutOfOrder(entry) => entry,
+        }
+    }
+
+    /// Retrieves all leading parts of `key`
+    pub fn leading(&self, key: &K) -> &[V] {
+        match self.index.get(key) {
+            None => &[],
+            Some(Entry::InOrder(in_order)) => &self.parts[in_order.leading_range()],
+            Some(Entry::OutOfOrder(entry)) => &self.out_of_order[entry.leading_index()],
+        }
+    }
+
+    /// Retrieves all dangling parts of `key`.
+    pub fn dangling(&self, key: &K) -> &[V] {
+        match self.index.get(key) {
+            None => &[],
+            Some(Entry::InOrder(in_order)) => &self.parts[in_order.dangling_range()],
+            Some(Entry::OutOfOrder(entry)) => &self.out_of_order[entry.dangling_index()],
+        }
+    }
+
+    /// Retrieves all trailing parts of `key`.
+    pub fn trailing(&self, key: &K) -> &[V] {
+        match self.index.get(key) {
+            None => &[],
+            Some(Entry::InOrder(in_order)) => &self.parts[in_order.trailing_range()],
+            Some(Entry::OutOfOrder(entry)) => &self.out_of_order[entry.trailing_index()],
+        }
+    }
+
+    /// Returns `true` if `key` has any leading, dangling, or trailing part.
+    pub fn has(&self, key: &K) -> bool {
+        self.index.get(key).is_some()
+    }
+
+    /// Returns an iterator over all leading, dangling, and trailing parts of `key`.
+    pub fn parts(&self, key: &K) -> PartsIterator<V> {
+        match self.index.get(key) {
+            None => PartsIterator::Slice([].iter()),
+            Some(Entry::OutOfOrder(entry)) => PartsIterator::Leading {
+                leading: self.out_of_order[entry.leading_index()].iter(),
+                dangling: &self.out_of_order[entry.dangling_index()],
+                trailing: &self.out_of_order[entry.trailing_index()],
+            },
+            Some(Entry::InOrder(entry)) => PartsIterator::Slice(self.parts[entry.range()].iter()),
+        }
+    }
+}
+
+impl<K: std::hash::Hash + Eq, V> Default for CommentsMap<K, V> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<K, V> std::fmt::Debug for CommentsMap<K, V>
+where
+    K: std::fmt::Debug,
+    V: std::fmt::Debug,
+{
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let mut builder = f.debug_map();
+
+        for (key, entry) in &self.index {
+            builder.entry(&key, &DebugEntry { entry, map: self });
+        }
+
+        builder.finish()
+    }
+}
+
+/// Iterator to iterate over all leading, dangling, and trailing parts of a key.
+pub(super) enum PartsIterator<'a, V> {
+    /// The slice into the [CommentsMap::parts] [Vec] if this is an in-order entry or the trailing parts
+    /// of an out-of-order entry.
+    Slice(std::slice::Iter<'a, V>),
+
+    /// Iterator over the leading parts of an out-of-order entry. Returns the dangling parts, and then the
+    /// trailing parts once the leading iterator is fully consumed.
+    Leading {
+        leading: std::slice::Iter<'a, V>,
+        dangling: &'a [V],
+        trailing: &'a [V],
+    },
+
+    /// Iterator over the dangling parts of an out-of-order entry. Returns the trailing parts
+    /// once the leading iterator is fully consumed.
+    Dangling {
+        dangling: std::slice::Iter<'a, V>,
+        trailing: &'a [V],
+    },
+}
+
+impl<'a, V> Iterator for PartsIterator<'a, V> {
+    type Item = &'a V;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        match self {
+            PartsIterator::Slice(inner) => inner.next(),
+
+            PartsIterator::Leading {
+                leading,
+                dangling,
+                trailing,
+            } => match leading.next() {
+                Some(next) => Some(next),
+                None if !dangling.is_empty() => {
+                    let mut dangling_iterator = dangling.iter();
+                    let next = dangling_iterator.next().unwrap();
+                    *self = PartsIterator::Dangling {
+                        dangling: dangling_iterator,
+                        trailing,
+                    };
+                    Some(next)
+                }
+                None => {
+                    let mut trailing_iterator = trailing.iter();
+                    let next = trailing_iterator.next();
+                    *self = PartsIterator::Slice(trailing_iterator);
+                    next
+                }
+            },
+
+            PartsIterator::Dangling { dangling, trailing } => match dangling.next() {
+                Some(next) => Some(next),
+                None => {
+                    let mut trailing_iterator = trailing.iter();
+                    let next = trailing_iterator.next();
+                    *self = PartsIterator::Slice(trailing_iterator);
+                    next
+                }
+            },
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        match self {
+            PartsIterator::Slice(slice) => slice.size_hint(),
+            PartsIterator::Leading {
+                leading,
+                dangling,
+                trailing,
+            } => {
+                let len = leading.len() + dangling.len() + trailing.len();
+
+                (len, Some(len))
+            }
+            PartsIterator::Dangling { dangling, trailing } => {
+                let len = dangling.len() + trailing.len();
+                (len, Some(len))
+            }
+        }
+    }
+
+    fn last(self) -> Option<Self::Item>
+    where
+        Self: Sized,
+    {
+        match self {
+            PartsIterator::Slice(slice) => slice.last(),
+            PartsIterator::Leading {
+                leading,
+                dangling,
+                trailing,
+            } => trailing
+                .last()
+                .or_else(|| dangling.last())
+                .or_else(|| leading.last()),
+            PartsIterator::Dangling { dangling, trailing } => {
+                trailing.last().or_else(|| dangling.last())
+            }
+        }
+    }
+}
+
+impl<V> ExactSizeIterator for PartsIterator<'_, V> {}
+
+impl<V> FusedIterator for PartsIterator<'_, V> {}
+
+#[derive(Debug)]
+enum Entry {
+    InOrder(InOrderEntry),
+    OutOfOrder(OutOfOrderEntry),
+}
+
+struct DebugEntry<'a, K, V> {
+    entry: &'a Entry,
+    map: &'a CommentsMap<K, V>,
+}
+
+impl<K, V> Debug for DebugEntry<'_, K, V>
+where
+    K: Debug,
+    V: Debug,
+{
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        let leading = match self.entry {
+            Entry::OutOfOrder(entry) => self.map.out_of_order[entry.leading_index()].as_slice(),
+            Entry::InOrder(entry) => &self.map.parts[entry.leading_range()],
+        };
+
+        let dangling = match self.entry {
+            Entry::OutOfOrder(entry) => self.map.out_of_order[entry.dangling_index()].as_slice(),
+            Entry::InOrder(entry) => &self.map.parts[entry.dangling_range()],
+        };
+
+        let trailing = match self.entry {
+            Entry::OutOfOrder(entry) => self.map.out_of_order[entry.trailing_index()].as_slice(),
+            Entry::InOrder(entry) => &self.map.parts[entry.trailing_range()],
+        };
+
+        let mut list = f.debug_list();
+
+        list.entries(leading.iter().map(DebugValue::Leading));
+        list.entries(dangling.iter().map(DebugValue::Dangling));
+        list.entries(trailing.iter().map(DebugValue::Trailing));
+
+        list.finish()
+    }
+}
+
+enum DebugValue<'a, V> {
+    Leading(&'a V),
+    Dangling(&'a V),
+    Trailing(&'a V),
+}
+
+impl<V> Debug for DebugValue<'_, V>
+where
+    V: Debug,
+{
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            DebugValue::Leading(leading) => f.debug_tuple("Leading").field(leading).finish(),
+            DebugValue::Dangling(dangling) => f.debug_tuple("Dangling").field(dangling).finish(),
+            DebugValue::Trailing(trailing) => f.debug_tuple("Trailing").field(trailing).finish(),
+        }
+    }
+}
+
+#[derive(Debug)]
+struct InOrderEntry {
+    /// Index into the [CommentsMap::parts] vector where the leading parts of this entry start
+    leading_start: PartIndex,
+
+    /// Index into the [CommentsMap::parts] vector where the dangling parts (and, thus, the leading parts end) start.
+    dangling_start: PartIndex,
+
+    /// Index into the [CommentsMap::parts] vector where the trailing parts (and, thus, the dangling parts end) of this entry start
+    trailing_start: Option<PartIndex>,
+
+    /// Index into the [CommentsMap::parts] vector where the trailing parts of this entry end
+    trailing_end: Option<PartIndex>,
+
+    _count: Count<InOrderEntry>,
+}
+
+impl InOrderEntry {
+    fn leading(range: Range<usize>) -> Self {
+        InOrderEntry {
+            leading_start: PartIndex::from_len(range.start),
+            dangling_start: PartIndex::from_len(range.end),
+            trailing_start: None,
+            trailing_end: None,
+            _count: Count::new(),
+        }
+    }
+
+    fn dangling(range: Range<usize>) -> Self {
+        let start = PartIndex::from_len(range.start);
+        InOrderEntry {
+            leading_start: start,
+            dangling_start: start,
+            trailing_start: Some(PartIndex::from_len(range.end)),
+            trailing_end: None,
+            _count: Count::new(),
+        }
+    }
+
+    fn trailing(range: Range<usize>) -> Self {
+        let start = PartIndex::from_len(range.start);
+        InOrderEntry {
+            leading_start: start,
+            dangling_start: start,
+            trailing_start: Some(start),
+            trailing_end: Some(PartIndex::from_len(range.end)),
+            _count: Count::new(),
+        }
+    }
+
+    fn increment_leading_range(&mut self) {
+        assert!(
+            self.trailing_start.is_none(),
+            "Can't extend the leading range for an in order entry with dangling comments."
+        );
+
+        self.dangling_start.increment();
+    }
+
+    fn increment_dangling_range(&mut self) {
+        assert!(
+            self.trailing_end.is_none(),
+            "Can't extend the dangling range for an in order entry with trailing comments."
+        );
+
+        match &mut self.trailing_start {
+            Some(start) => start.increment(),
+            None => self.trailing_start = Some(self.dangling_start.incremented()),
+        }
+    }
+
+    fn increment_trailing_range(&mut self) {
+        match (self.trailing_start, &mut self.trailing_end) {
+            // Already has some trailing comments
+            (Some(_), Some(end)) => end.increment(),
+            // Has dangling comments only
+            (Some(start), None) => self.trailing_end = Some(start.incremented()),
+            // Has leading comments only
+            (None, None) => {
+                self.trailing_start = Some(self.dangling_start);
+                self.trailing_end = Some(self.dangling_start.incremented())
+            }
+            (None, Some(_)) => {
+                unreachable!()
+            }
+        }
+    }
+
+    fn leading_range(&self) -> Range<usize> {
+        self.leading_start.value()..self.dangling_start.value()
+    }
+
+    fn dangling_range(&self) -> Range<usize> {
+        match self.trailing_start {
+            None => self.dangling_start.value()..self.dangling_start.value(),
+            Some(trailing_start) => self.dangling_start.value()..trailing_start.value(),
+        }
+    }
+
+    fn trailing_range(&self) -> Range<usize> {
+        match (self.trailing_start, self.trailing_end) {
+            (Some(trailing_start), Some(trailing_end)) => {
+                trailing_start.value()..trailing_end.value()
+            }
+            // Only dangling comments
+            (Some(trailing_start), None) => trailing_start.value()..trailing_start.value(),
+            (None, Some(_)) => {
+                panic!("Trailing end shouldn't be set if trailing start is none");
+            }
+            (None, None) => self.dangling_start.value()..self.dangling_start.value(),
+        }
+    }
+
+    fn range(&self) -> Range<usize> {
+        self.leading_start.value()
+            ..self
+                .trailing_end
+                .or(self.trailing_start)
+                .unwrap_or(self.dangling_start)
+                .value()
+    }
+}
+
+#[derive(Debug)]
+struct OutOfOrderEntry {
+    /// Index into the [CommentsMap::out_of_order] vector at which offset the leaading vec is stored.
+    leading_index: usize,
+    _count: Count<OutOfOrderEntry>,
+}
+
+impl OutOfOrderEntry {
+    const fn leading_index(&self) -> usize {
+        self.leading_index
+    }
+
+    const fn dangling_index(&self) -> usize {
+        self.leading_index + 1
+    }
+
+    const fn trailing_index(&self) -> usize {
+        self.leading_index + 2
+    }
+}
+
+/// Index into the [CommentsMap::parts] vector.
+///
+/// Stores the index as a [NonZeroU32], starting at 1 instead of 0 so that
+/// `size_of::<PartIndex>() == size_of::<Option<PartIndex>>()`.
+///
+/// This means, that only `u32 - 1` parts can be stored. This should be sufficient for storing comments
+/// because: Comments have length of two or more bytes because they consist of a start and end character sequence (`#` + new line, `/*` and `*/`).
+/// Thus, a document with length `u32` can have at most `u32::MAX / 2` comment-parts.
+#[repr(transparent)]
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
+struct PartIndex(NonZeroU32);
+
+impl PartIndex {
+    fn from_len(value: usize) -> Self {
+        Self(NonZeroU32::try_from(value as u32 + 1).unwrap())
+    }
+
+    fn value(&self) -> usize {
+        (u32::from(self.0) - 1) as usize
+    }
+
+    fn increment(&mut self) {
+        *self = self.incremented();
+    }
+
+    fn incremented(&self) -> PartIndex {
+        PartIndex(NonZeroU32::new(self.0.get() + 1).unwrap())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::comments::map::CommentsMap;
+
+    static EMPTY: [i32; 0] = [];
+
+    #[test]
+    fn leading_dangling_trailing() {
+        let mut map = CommentsMap::new();
+
+        map.push_leading("a", 1);
+        map.push_dangling("a", 2);
+        map.push_dangling("a", 3);
+        map.push_trailing("a", 4);
+
+        assert_eq!(map.parts, vec![1, 2, 3, 4]);
+
+        assert_eq!(map.leading(&"a"), &[1]);
+        assert_eq!(map.dangling(&"a"), &[2, 3]);
+        assert_eq!(map.trailing(&"a"), &[4]);
+
+        assert!(map.has(&"a"));
+
+        assert_eq!(
+            map.parts(&"a").copied().collect::<Vec<_>>(),
+            vec![1, 2, 3, 4]
+        );
+    }
+
+    #[test]
+    fn dangling_trailing() {
+        let mut map = CommentsMap::new();
+
+        map.push_dangling("a", 1);
+        map.push_dangling("a", 2);
+        map.push_trailing("a", 3);
+
+        assert_eq!(map.parts, vec![1, 2, 3]);
+
+        assert_eq!(map.leading(&"a"), &EMPTY);
+        assert_eq!(map.dangling(&"a"), &[1, 2]);
+        assert_eq!(map.trailing(&"a"), &[3]);
+
+        assert!(map.has(&"a"));
+
+        assert_eq!(map.parts(&"a").copied().collect::<Vec<_>>(), vec![1, 2, 3]);
+    }
+
+    #[test]
+    fn trailing() {
+        let mut map = CommentsMap::new();
+
+        map.push_trailing("a", 1);
+        map.push_trailing("a", 2);
+
+        assert_eq!(map.parts, vec![1, 2]);
+
+        assert_eq!(map.leading(&"a"), &EMPTY);
+        assert_eq!(map.dangling(&"a"), &EMPTY);
+        assert_eq!(map.trailing(&"a"), &[1, 2]);
+
+        assert!(map.has(&"a"));
+
+        assert_eq!(map.parts(&"a").copied().collect::<Vec<_>>(), vec![1, 2]);
+    }
+
+    #[test]
+    fn empty() {
+        let map = CommentsMap::<&str, i32>::default();
+
+        assert_eq!(map.parts, Vec::<i32>::new());
+
+        assert_eq!(map.leading(&"a"), &EMPTY);
+        assert_eq!(map.dangling(&"a"), &EMPTY);
+        assert_eq!(map.trailing(&"a"), &EMPTY);
+
+        assert!(!map.has(&"a"));
+
+        assert_eq!(
+            map.parts(&"a").copied().collect::<Vec<_>>(),
+            Vec::<i32>::new()
+        );
+    }
+
+    #[test]
+    fn multiple_keys() {
+        let mut map = CommentsMap::new();
+
+        map.push_leading("a", 1);
+        map.push_dangling("b", 2);
+        map.push_trailing("c", 3);
+        map.push_leading("d", 4);
+        map.push_dangling("d", 5);
+        map.push_trailing("d", 6);
+
+        assert_eq!(map.parts, &[1, 2, 3, 4, 5, 6]);
+
+        assert_eq!(map.leading(&"a"), &[1]);
+        assert_eq!(map.dangling(&"a"), &EMPTY);
+        assert_eq!(map.trailing(&"a"), &EMPTY);
+        assert_eq!(map.parts(&"a").copied().collect::<Vec<_>>(), vec![1]);
+
+        assert_eq!(map.leading(&"b"), &EMPTY);
+        assert_eq!(map.dangling(&"b"), &[2]);
+        assert_eq!(map.trailing(&"b"), &EMPTY);
+        assert_eq!(map.parts(&"b").copied().collect::<Vec<_>>(), vec![2]);
+
+        assert_eq!(map.leading(&"c"), &EMPTY);
+        assert_eq!(map.dangling(&"c"), &EMPTY);
+        assert_eq!(map.trailing(&"c"), &[3]);
+        assert_eq!(map.parts(&"c").copied().collect::<Vec<_>>(), vec![3]);
+
+        assert_eq!(map.leading(&"d"), &[4]);
+        assert_eq!(map.dangling(&"d"), &[5]);
+        assert_eq!(map.trailing(&"d"), &[6]);
+        assert_eq!(map.parts(&"d").copied().collect::<Vec<_>>(), vec![4, 5, 6]);
+    }
+
+    #[test]
+    fn dangling_leading() {
+        let mut map = CommentsMap::new();
+
+        map.push_dangling("a", 1);
+        map.push_leading("a", 2);
+        map.push_dangling("a", 3);
+        map.push_trailing("a", 4);
+
+        assert_eq!(map.leading(&"a"), [2]);
+        assert_eq!(map.dangling(&"a"), [1, 3]);
+        assert_eq!(map.trailing(&"a"), [4]);
+
+        assert_eq!(
+            map.parts(&"a").copied().collect::<Vec<_>>(),
+            vec![2, 1, 3, 4]
+        );
+
+        assert!(map.has(&"a"));
+    }
+
+    #[test]
+    fn trailing_leading() {
+        let mut map = CommentsMap::new();
+
+        map.push_trailing("a", 1);
+        map.push_leading("a", 2);
+        map.push_dangling("a", 3);
+        map.push_trailing("a", 4);
+
+        assert_eq!(map.leading(&"a"), [2]);
+        assert_eq!(map.dangling(&"a"), [3]);
+        assert_eq!(map.trailing(&"a"), [1, 4]);
+
+        assert_eq!(
+            map.parts(&"a").copied().collect::<Vec<_>>(),
+            vec![2, 3, 1, 4]
+        );
+
+        assert!(map.has(&"a"));
+    }
+
+    #[test]
+    fn trailing_dangling() {
+        let mut map = CommentsMap::new();
+
+        map.push_trailing("a", 1);
+        map.push_dangling("a", 2);
+        map.push_trailing("a", 3);
+
+        assert_eq!(map.leading(&"a"), &EMPTY);
+        assert_eq!(map.dangling(&"a"), &[2]);
+        assert_eq!(map.trailing(&"a"), &[1, 3]);
+
+        assert_eq!(map.parts(&"a").copied().collect::<Vec<_>>(), vec![2, 1, 3]);
+
+        assert!(map.has(&"a"));
+    }
+
+    #[test]
+    fn keys_out_of_order() {
+        let mut map = CommentsMap::new();
+
+        map.push_leading("a", 1);
+        map.push_dangling("b", 2);
+        map.push_leading("a", 3);
+
+        map.push_trailing("c", 4);
+        map.push_dangling("b", 5);
+
+        map.push_leading("d", 6);
+        map.push_trailing("c", 7);
+
+        assert_eq!(map.leading(&"a"), &[1, 3]);
+        assert_eq!(map.dangling(&"b"), &[2, 5]);
+        assert_eq!(map.trailing(&"c"), &[4, 7]);
+
+        assert!(map.has(&"a"));
+        assert!(map.has(&"b"));
+        assert!(map.has(&"c"));
+    }
+}

From f9a0398df3cf7cccc612acfd1546fdfc618dba31 Mon Sep 17 00:00:00 2001
From: Micha Reiser <micha@rome.tools>
Date: Thu, 15 Sep 2022 14:01:28 +0200
Subject: [PATCH 04/15] Comments infrastructure

---
 Cargo.lock                                    |   2 +
 crates/rome_formatter/Cargo.toml              |   4 +
 crates/rome_formatter/src/comments.rs         | 555 ++++++++--
 crates/rome_formatter/src/comments/builder.rs | 999 ++++++++++++++++++
 crates/rome_formatter/src/lib.rs              |  22 +-
 5 files changed, 1458 insertions(+), 124 deletions(-)
 create mode 100644 crates/rome_formatter/src/comments/builder.rs

diff --git a/Cargo.lock b/Cargo.lock
index 646804faacb..4ad4eab2e64 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1587,6 +1587,8 @@ dependencies = [
  "cfg-if",
  "countme",
  "indexmap",
+ "rome_js_parser",
+ "rome_js_syntax",
  "rome_rowan",
  "rustc-hash",
  "schemars",
diff --git a/crates/rome_formatter/Cargo.toml b/crates/rome_formatter/Cargo.toml
index fde1f730112..5c63d0c7b5b 100644
--- a/crates/rome_formatter/Cargo.toml
+++ b/crates/rome_formatter/Cargo.toml
@@ -18,5 +18,9 @@ schemars = { version = "0.8.10", optional = true }
 rustc-hash = "1.1.0"
 countme = "3.0.1"
 
+[dev-dependencies]
+rome_js_parser = { path = "../rome_js_parser"}
+rome_js_syntax = { path = "../rome_js_syntax" }
+
 [features]
 serde = ["dep:serde", "schemars", "rome_rowan/serde"]
diff --git a/crates/rome_formatter/src/comments.rs b/crates/rome_formatter/src/comments.rs
index 4c53a59b443..f022ae8bbee 100644
--- a/crates/rome_formatter/src/comments.rs
+++ b/crates/rome_formatter/src/comments.rs
@@ -1,12 +1,13 @@
+mod builder;
 mod map;
 
-use rome_rowan::{
-    Direction, Language, SyntaxElement, SyntaxKind, SyntaxNode, SyntaxTriviaPieceComments,
-    WalkEvent,
-};
+use self::{builder::CommentsBuilderVisitor, map::CommentsMap};
+use crate::{TextSize, TransformSourceMap};
+use rome_rowan::syntax::SyntaxElementKey;
+use rome_rowan::{Language, SyntaxNode, SyntaxToken, SyntaxTriviaPieceComments};
+use rustc_hash::FxHashSet;
 #[cfg(debug_assertions)]
 use std::cell::RefCell;
-use std::collections::HashSet;
 use std::rc::Rc;
 
 #[derive(Copy, Clone, Eq, PartialEq, Debug)]
@@ -47,43 +48,6 @@ pub enum CommentKind {
     Line,
 }
 
-#[derive(Debug, Clone)]
-pub struct SourceComment<L: Language> {
-    /// The number of lines appearing before this comment
-    lines_before: u32,
-
-    /// The comment piece
-    piece: SyntaxTriviaPieceComments<L>,
-}
-
-impl<L: Language> SourceComment<L> {
-    /// Creates a new trailing comment. A trailing comment always has 0 lines before.
-    pub fn trailing(piece: SyntaxTriviaPieceComments<L>) -> Self {
-        Self {
-            lines_before: 0,
-            piece,
-        }
-    }
-
-    /// Creates a leading comment with the specified lines before
-    pub fn leading(piece: SyntaxTriviaPieceComments<L>, lines_before: u32) -> Self {
-        Self {
-            lines_before,
-            piece,
-        }
-    }
-
-    /// Returns the underlining comment trivia piece
-    pub fn piece(&self) -> &SyntaxTriviaPieceComments<L> {
-        &self.piece
-    }
-
-    /// Returns the number of lines before directly before this comment
-    pub fn lines_before(&self) -> u32 {
-        self.lines_before
-    }
-}
-
 impl CommentKind {
     pub const fn is_line(&self) -> bool {
         matches!(self, CommentKind::Line)
@@ -116,24 +80,236 @@ impl CommentKind {
     }
 }
 
+#[derive(Debug, Clone)]
+pub struct SourceComment<L: Language> {
+    /// The number of lines appearing before this comment
+    pub(crate) lines_before: u32,
+
+    pub(crate) lines_after: u32,
+
+    /// The comment piece
+    pub(crate) piece: SyntaxTriviaPieceComments<L>,
+
+    pub(crate) kind: CommentKind,
+}
+
+impl<L: Language> SourceComment<L> {
+    /// Returns the underlining comment trivia piece
+    pub fn piece(&self) -> &SyntaxTriviaPieceComments<L> {
+        &self.piece
+    }
+
+    /// Returns the number of lines before directly before this comment
+    pub fn lines_before(&self) -> u32 {
+        self.lines_before
+    }
+
+    pub fn lines_after(&self) -> u32 {
+        self.lines_after
+    }
+
+    /// The kind of the comment
+    pub fn kind(&self) -> CommentKind {
+        self.kind
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct DecoratedComment<L: Language> {
+    enclosing: SyntaxNode<L>,
+    preceding: Option<SyntaxNode<L>>,
+    following: Option<SyntaxNode<L>>,
+    following_token: SyntaxToken<L>,
+    position: CommentTextPosition,
+    lines_before: u32,
+    lines_after: u32,
+    comment: SyntaxTriviaPieceComments<L>,
+    kind: CommentKind,
+}
+
+impl<L: Language> DecoratedComment<L> {
+    /// The node that fully encloses the comment (the comment's start and end position are fully in the
+    /// node's bounds).
+    pub fn enclosing_node(&self) -> &SyntaxNode<L> {
+        &self.enclosing
+    }
+
+    pub fn piece(&self) -> &SyntaxTriviaPieceComments<L> {
+        &self.comment
+    }
+
+    /// The node directly preceding the comment or [None] if the comment is preceded by a token or is the first
+    /// token in the program.
+    pub fn preceding_node(&self) -> Option<&SyntaxNode<L>> {
+        self.preceding.as_ref()
+    }
+
+    fn take_preceding_node(&mut self) -> Option<SyntaxNode<L>> {
+        self.preceding.take()
+    }
+
+    /// The node directly following the comment or [None] if the comment is followed by a token or is the last token in the program.
+    pub fn following_node(&self) -> Option<&SyntaxNode<L>> {
+        self.following.as_ref()
+    }
+
+    fn take_following_node(&mut self) -> Option<SyntaxNode<L>> {
+        self.following.take()
+    }
+
+    /// The number of lines between this comment and the **previous** token, comment or skipped trivia.
+    pub fn lines_before(&self) -> u32 {
+        self.lines_before
+    }
+
+    pub fn lines_after(&self) -> u32 {
+        self.lines_after
+    }
+
+    /// Returns the [kind](CommentKind) of the comment.
+    pub fn kind(&self) -> CommentKind {
+        self.kind
+    }
+
+    pub fn position(&self) -> CommentTextPosition {
+        self.position
+    }
+
+    pub fn following_token(&self) -> &SyntaxToken<L> {
+        &self.following_token
+    }
+}
+
+impl<L: Language> From<DecoratedComment<L>> for SourceComment<L> {
+    fn from(decorated: DecoratedComment<L>) -> Self {
+        Self {
+            lines_before: decorated.lines_before,
+            lines_after: decorated.lines_after,
+            piece: decorated.comment,
+            kind: decorated.kind,
+        }
+    }
+}
+
+/// The position of a comment in the source document.
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+pub enum CommentTextPosition {
+    /// A comment that is separated by at least one line break from the following token
+    ///
+    /// ```javascript
+    /// a; /* this */ // or this
+    /// b;
+    EndOfLine,
+
+    /// A Comment that is separated by at least one line break from the preceding token
+    ///
+    /// ```javascript
+    /// a;
+    /// /* comment */ /* or this */
+    /// b;
+    /// ```
+    OwnLine,
+
+    /// A comment that is placed on the same line as the preceding and following token.
+    ///
+    /// ```javascript
+    /// a /* comment */ + b
+    /// ```
+    SameLine,
+}
+
+impl CommentTextPosition {
+    pub const fn is_same_line(&self) -> bool {
+        matches!(self, CommentTextPosition::SameLine)
+    }
+
+    pub const fn is_own_line(&self) -> bool {
+        matches!(self, CommentTextPosition::OwnLine)
+    }
+
+    pub const fn is_end_of_line(&self) -> bool {
+        matches!(self, CommentTextPosition::EndOfLine)
+    }
+}
+
+#[derive(Debug)]
+pub enum CommentPlacement<L: Language> {
+    /// Overrides the positioning of the comment to be a leading node comment.
+    Leading {
+        node: SyntaxNode<L>,
+        comment: SourceComment<L>,
+    },
+    /// Overrides the positioning of the comment to be a trailing node comment.
+    Trailing {
+        node: SyntaxNode<L>,
+        comment: SourceComment<L>,
+    },
+
+    /// Makes this comment a dangling comment of `node`
+    Dangling {
+        node: SyntaxNode<L>,
+        comment: SourceComment<L>,
+    },
+
+    /// Uses the default positioning rules for the comment.
+    /// TODO document rules
+    Default(DecoratedComment<L>),
+}
+
+impl<L: Language> CommentPlacement<L> {
+    #[inline]
+    pub fn leading(node: SyntaxNode<L>, comment: impl Into<SourceComment<L>>) -> Self {
+        Self::Leading {
+            node,
+            comment: comment.into(),
+        }
+    }
+
+    pub fn dangling(node: SyntaxNode<L>, comment: impl Into<SourceComment<L>>) -> Self {
+        Self::Dangling {
+            node,
+            comment: comment.into(),
+        }
+    }
+
+    #[inline]
+    pub fn trailing(node: SyntaxNode<L>, comment: impl Into<SourceComment<L>>) -> Self {
+        Self::Trailing {
+            node,
+            comment: comment.into(),
+        }
+    }
+
+    #[inline]
+    pub fn or_else<F>(self, or_else: F) -> Self
+    where
+        F: FnOnce(DecoratedComment<L>) -> CommentPlacement<L>,
+    {
+        match self {
+            CommentPlacement::Default(comment) => or_else(comment),
+            placement => placement,
+        }
+    }
+}
+
 /// Defines how to format comments for a specific [Language].
-pub trait CommentStyle<L: Language> {
+pub trait CommentStyle: Default {
+    type Language: Language;
+
     /// Returns `true` if a comment with the given `text` is a `rome-ignore format:` suppression comment.
-    fn is_suppression(&self, text: &str) -> bool;
+    fn is_suppression(_text: &str) -> bool {
+        false
+    }
 
     /// Returns the (kind)[CommentKind] of the comment
-    fn get_comment_kind(&self, comment: &SyntaxTriviaPieceComments<L>) -> CommentKind;
-
-    /// Returns `true` if a token with the passed `kind` marks the start of a group. Common group tokens are:
-    /// * left parentheses: `(`, `[`, `{`
-    fn is_group_start_token(&self, kind: L::Kind) -> bool;
-
-    /// Returns `true` if a token with the passed `kind` marks the end of a group. Common group end tokens are:
-    /// * right parentheses: `)`, `]`, `}`
-    /// * end of statement token: `;`
-    /// * element separator: `,` or `.`.
-    /// * end of file token: `EOF`
-    fn is_group_end_token(&self, kind: L::Kind) -> bool;
+    fn get_comment_kind(comment: &SyntaxTriviaPieceComments<Self::Language>) -> CommentKind;
+
+    fn place_comment(
+        &self,
+        comment: DecoratedComment<Self::Language>,
+    ) -> CommentPlacement<Self::Language> {
+        CommentPlacement::Default(comment)
+    }
 }
 
 /// Type that stores the comments of a tree and gives access to:
@@ -143,7 +319,7 @@ pub trait CommentStyle<L: Language> {
 /// * the dangling comments of a token
 ///
 /// Cloning `comments` is cheap as it only involves bumping a reference counter.
-#[derive(Debug, Default, Clone)]
+#[derive(Debug, Clone, Default)]
 pub struct Comments<L: Language> {
     /// The use of a [Rc] is necessary to achieve that [Comments] has a lifetime that is independent from the [crate::Formatter].
     /// Having independent lifetimes is necessary to support the use case where a (formattable object)[crate::Format]
@@ -165,65 +341,117 @@ pub struct Comments<L: Language> {
 
 impl<L: Language> Comments<L> {
     /// Extracts all the suppressions from `root` and its child nodes.
-    pub fn from_node<FormatLanguage>(root: &SyntaxNode<L>, language: &FormatLanguage) -> Self
+    pub fn from_node<Style>(
+        root: &SyntaxNode<L>,
+        style: &Style,
+        source_map: Option<&TransformSourceMap>,
+    ) -> Self
     where
-        FormatLanguage: crate::FormatLanguage<SyntaxLanguage = L>,
+        Style: CommentStyle<Language = L>,
     {
-        let mut suppressed_nodes = HashSet::new();
-        let mut current_node = None;
-
-        for event in root.preorder_with_tokens(Direction::Next) {
-            match event {
-                WalkEvent::Enter(SyntaxElement::Node(node)) => {
-                    // Lists cannot have a suppression comment attached, it must
-                    // belong to either the entire parent node or one of the children
-                    if node.kind().is_root() || node.kind().is_list() {
-                        continue;
-                    }
-
-                    if current_node.is_none() {
-                        current_node = Some(node);
-                    }
-                }
-                WalkEvent::Leave(SyntaxElement::Node(node)) => {
-                    if current_node == Some(node) {
-                        current_node = None;
-                    }
-                }
-                WalkEvent::Enter(SyntaxElement::Token(token)) => {
-                    if let Some(current_node) = current_node.take() {
-                        for comment in token
-                            .leading_trivia()
-                            .pieces()
-                            .filter_map(|piece| piece.as_comments())
-                        {
-                            if language.comment_style().is_suppression(comment.text()) {
-                                suppressed_nodes.insert(current_node);
-                                break;
-                            }
-                        }
-                    }
-                }
-                WalkEvent::Leave(SyntaxElement::Token(_)) => {
-                    // Token already handled as part of the enter event.
-                }
-            }
-        }
+        let builder = CommentsBuilderVisitor::new(style, source_map);
 
-        let data = CommentsData {
-            suppressed_nodes,
-            #[cfg(debug_assertions)]
-            checked_suppressions: RefCell::default(),
-        };
+        let (comments, skipped) = builder.visit(root);
 
         Self {
-            data: Rc::new(data),
+            data: Rc::new(CommentsData {
+                root: Some(root.clone()),
+                is_suppression: Style::is_suppression,
+
+                comments,
+                with_skipped: skipped,
+                #[cfg(debug_assertions)]
+                checked_suppressions: RefCell::new(Default::default()),
+            }),
         }
     }
 
+    /// Returns `true` if the given `node` has any leading or trailing comments.
+    #[inline]
+    pub fn has_comments(&self, node: &SyntaxNode<L>) -> bool {
+        self.data.comments.has(&node.key())
+    }
+
+    /// Returns `true` if the given [node] has any leading comments.
+    /// By default, a comment is a node's leading comment if:
+    /// * the previous sibling is a token
+    /// * there's a line break before the commend ending before this comment and the comment.
+    #[inline]
+    pub fn has_leading_comments(&self, node: &SyntaxNode<L>) -> bool {
+        !self.leading_comments(node).is_empty()
+    }
+
+    /// Tests if the node has any leading comment that will be placed on its own line.
+    pub fn has_leading_own_line_comment(&self, node: &SyntaxNode<L>) -> bool {
+        self.leading_comments(node)
+            .iter()
+            .any(|comment| comment.lines_after() > 0)
+    }
+
+    /// Returns the [node]'s leading comments.
+    #[inline]
+    pub fn leading_comments(&self, node: &SyntaxNode<L>) -> &[SourceComment<L>] {
+        self.data.comments.leading(&node.key())
+    }
+
+    /// Returns `true` if node has any dangling comments.
+    pub fn has_dangling_comments(&self, node: &SyntaxNode<L>) -> bool {
+        !self.dangling_comments(node).is_empty()
+    }
+
+    /// Returns the dangling comments of `node`
+    pub fn dangling_comments(&self, node: &SyntaxNode<L>) -> &[SourceComment<L>] {
+        self.data.comments.dangling(&node.key())
+    }
+
+    /// Returns the [node]'s trailing comments.
+    #[inline]
+    pub fn trailing_comments(&self, node: &SyntaxNode<L>) -> &[SourceComment<L>] {
+        self.data.comments.trailing(&node.key())
+    }
+
+    pub fn has_trailing_line_comment(&self, node: &SyntaxNode<L>) -> bool {
+        self.trailing_comments(node)
+            .iter()
+            .any(|comment| comment.kind().is_line())
+    }
+
+    /// Returns `true` if the given [node] has any trailing comments.
+    /// By default, a comment is a node's trailing comment if:
+    /// * the next sibling is a token
+    /// * there's **no** line break between the node and this comment.
+    #[inline]
+    pub fn has_trailing_comments(&self, node: &SyntaxNode<L>) -> bool {
+        !self.trailing_comments(node).is_empty()
+    }
+
+    /// Returns an iterator over the leading and trailing comments of `node`.
+    pub fn leading_trailing_comments(
+        &self,
+        node: &SyntaxNode<L>,
+    ) -> impl Iterator<Item = &SourceComment<L>> {
+        self.leading_comments(node)
+            .iter()
+            .chain(self.trailing_comments(node).iter())
+    }
+
+    /// Returns an iterator over the leading, dangling, and trailing comments of `node`.
+    pub fn leading_dangling_trailing_comments<'a>(
+        &'a self,
+        node: &'a SyntaxNode<L>,
+    ) -> impl Iterator<Item = &SourceComment<L>> + 'a {
+        self.data.comments.parts(&node.key())
+    }
+
+    /// Returns `true` if that node has skipped token trivia attached.
+    #[inline]
+    pub fn has_skipped(&self, token: &SyntaxToken<L>) -> bool {
+        self.data.with_skipped.contains(&token.key())
+    }
+
     /// Returns `true` if the passed `node` has a leading suppression comment.
     ///
-    /// Suppression comments only apply if they are at the start of a node and they suppress the most
+    /// Suppression comments only apply if they at the start of a node and they suppress the most
     /// outer node.
     ///
     /// # Examples
@@ -237,7 +465,10 @@ impl<L: Language> Comments<L> {
     /// call expression is nested inside of the expression statement.
     pub fn is_suppressed(&self, node: &SyntaxNode<L>) -> bool {
         self.mark_suppression_checked(node);
-        self.data.suppressed_nodes.contains(node)
+        let is_suppression = self.data.is_suppression;
+
+        self.leading_dangling_trailing_comments(node)
+            .any(|comment| is_suppression(comment.piece().text()))
     }
 
     /// Marks that it isn't necessary for the given node to check if it has been suppressed or not.
@@ -262,6 +493,8 @@ impl<L: Language> Comments<L> {
     pub(crate) fn assert_checked_all_suppressions(&self, root: &SyntaxNode<L>) {
         cfg_if::cfg_if! {
             if #[cfg(debug_assertions)] {
+                use rome_rowan::SyntaxKind;
+
                 let checked_nodes = self.data.checked_suppressions.borrow();
                 for node in root.descendants() {
                     if node.kind().is_list() || node.kind().is_root() {
@@ -287,10 +520,14 @@ Node:
     }
 }
 
-#[derive(Debug, Default)]
 struct CommentsData<L: Language> {
-    /// Stores the nodes that have at least one leading suppression comment.
-    suppressed_nodes: HashSet<SyntaxNode<L>>,
+    root: Option<SyntaxNode<L>>,
+
+    is_suppression: fn(&str) -> bool,
+
+    /// Stores all leading node comments by node
+    comments: CommentsMap<SyntaxElementKey, SourceComment<L>>,
+    with_skipped: FxHashSet<SyntaxElementKey>,
 
     /// Stores all nodes for which [Comments::is_suppressed] has been called.
     /// This index of nodes that have been checked if they have a suppression comments is used to
@@ -301,5 +538,101 @@ struct CommentsData<L: Language> {
     /// as verbatim if its formatting fails which has the same result as formatting it as suppressed node
     /// (thus, guarantees that the formatting isn't changed).
     #[cfg(debug_assertions)]
-    checked_suppressions: RefCell<HashSet<SyntaxNode<L>>>,
+    checked_suppressions: RefCell<FxHashSet<SyntaxNode<L>>>,
+}
+
+impl<L: Language> Default for CommentsData<L> {
+    fn default() -> Self {
+        Self {
+            root: None,
+            is_suppression: |_| false,
+            comments: Default::default(),
+            with_skipped: Default::default(),
+            #[cfg(debug_assertions)]
+            checked_suppressions: Default::default(),
+        }
+    }
+}
+
+impl<L: Language> std::fmt::Debug for CommentsData<L> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let mut comments = Vec::new();
+
+        if let Some(root) = &self.root {
+            for node in root.descendants() {
+                for leading in self.comments.leading(&node.key()) {
+                    comments.push(DebugComment::Leading {
+                        node: node.clone(),
+                        comment: leading,
+                    });
+                }
+
+                for dangling in self.comments.dangling(&node.key()) {
+                    comments.push(DebugComment::Dangling {
+                        node: node.clone(),
+                        comment: dangling,
+                    });
+                }
+
+                for trailing in self.comments.trailing(&node.key()) {
+                    comments.push(DebugComment::Trailing {
+                        node: node.clone(),
+                        comment: trailing,
+                    });
+                }
+            }
+        }
+
+        comments.sort_by_key(|comment| comment.start());
+
+        f.debug_list().entries(comments).finish()
+    }
+}
+
+/// Helper for printing a comment of [Comments]
+enum DebugComment<'a, L: Language> {
+    Leading {
+        comment: &'a SourceComment<L>,
+        node: SyntaxNode<L>,
+    },
+    Trailing {
+        comment: &'a SourceComment<L>,
+        node: SyntaxNode<L>,
+    },
+    Dangling {
+        comment: &'a SourceComment<L>,
+        node: SyntaxNode<L>,
+    },
+}
+
+impl<L: Language> DebugComment<'_, L> {
+    fn start(&self) -> TextSize {
+        match self {
+            DebugComment::Leading { comment, .. }
+            | DebugComment::Trailing { comment, .. }
+            | DebugComment::Dangling { comment, .. } => comment.piece.text_range().start(),
+        }
+    }
+}
+
+impl<L: Language> std::fmt::Debug for DebugComment<'_, L> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            DebugComment::Leading { node, comment } => f
+                .debug_struct("Leading")
+                .field("node", node)
+                .field("comment", comment)
+                .finish(),
+            DebugComment::Dangling { node, comment } => f
+                .debug_struct("Dangling")
+                .field("node", node)
+                .field("comment", comment)
+                .finish(),
+            DebugComment::Trailing { node, comment } => f
+                .debug_struct("Trailing")
+                .field("node", node)
+                .field("comment", comment)
+                .finish(),
+        }
+    }
 }
diff --git a/crates/rome_formatter/src/comments/builder.rs b/crates/rome_formatter/src/comments/builder.rs
new file mode 100644
index 00000000000..c7484535e07
--- /dev/null
+++ b/crates/rome_formatter/src/comments/builder.rs
@@ -0,0 +1,999 @@
+use crate::comments::map::CommentsMap;
+use crate::comments::CommentTextPosition;
+use crate::source_map::{DeletedRangeEntry, DeletedRanges};
+use crate::{
+    CommentPlacement, CommentStyle, DecoratedComment, SourceComment, TextRange, TextSize,
+    TransformSourceMap,
+};
+use rome_rowan::syntax::SyntaxElementKey;
+use rome_rowan::{
+    Direction, Language, SyntaxElement, SyntaxKind, SyntaxNode, SyntaxToken, WalkEvent,
+};
+use rustc_hash::FxHashSet;
+
+pub(super) struct CommentsBuilderVisitor<'a, Style: CommentStyle> {
+    builder: CommentsBuilder<Style::Language>,
+    style: &'a Style,
+    parentheses: SourceParentheses<'a>,
+
+    // State
+    pending_comments: Vec<DecoratedComment<Style::Language>>,
+    preceding_node: Option<SyntaxNode<Style::Language>>,
+    following_node_index: Option<usize>,
+    parents: Vec<SyntaxNode<Style::Language>>,
+    last_token: Option<SyntaxToken<Style::Language>>,
+}
+
+impl<'a, Style> CommentsBuilderVisitor<'a, Style>
+where
+    Style: CommentStyle,
+{
+    pub(super) fn new(style: &'a Style, source_map: Option<&'a TransformSourceMap>) -> Self {
+        Self {
+            style,
+            builder: Default::default(),
+            parentheses: SourceParentheses::from_source_map(source_map),
+
+            pending_comments: Default::default(),
+            preceding_node: Default::default(),
+            following_node_index: Default::default(),
+            parents: Default::default(),
+            last_token: Default::default(),
+        }
+    }
+
+    pub(super) fn visit(
+        mut self,
+        root: &SyntaxNode<Style::Language>,
+    ) -> (
+        CommentsMap<SyntaxElementKey, SourceComment<Style::Language>>,
+        FxHashSet<SyntaxElementKey>,
+    ) {
+        for event in root.preorder_with_tokens(Direction::Next) {
+            match event {
+                WalkEvent::Enter(SyntaxElement::Node(node)) => {
+                    self.visit_node(WalkEvent::Enter(node))
+                }
+
+                WalkEvent::Leave(SyntaxElement::Node(node)) => {
+                    self.visit_node(WalkEvent::Leave(node))
+                }
+
+                WalkEvent::Enter(SyntaxElement::Token(token)) => self.visit_token(token),
+                WalkEvent::Leave(SyntaxElement::Token(_)) => {
+                    // Handled as part of enter
+                }
+            }
+        }
+
+        assert!(
+            self.parents.is_empty(),
+            "Expected all enclosing nodes to have been processed but contains {:#?}",
+            self.parents
+        );
+        self.flush_comments(None);
+
+        self.builder.finish()
+    }
+
+    fn visit_node(&mut self, event: WalkEvent<SyntaxNode<Style::Language>>) {
+        match event {
+            WalkEvent::Enter(node) => {
+                // Lists cannot have comments attached. They either belong to the entire parent or to
+                // the first child. So we ignore lists all together
+                if node.kind().is_list() {
+                    return;
+                }
+
+                let is_root = matches!(self.following_node_index, Some(0));
+
+                // Associate comments with the most outer node
+                // Set following here because it is the "following node" of the next token's leading trivia.
+                if self.following_node_index.is_none() || is_root {
+                    // Flush in case the node doesn't have any tokens.
+                    self.flush_comments(Some(&node));
+                    self.following_node_index = Some(self.parents.len());
+                }
+
+                self.parents.push(node);
+            }
+
+            WalkEvent::Leave(node) => {
+                if node.kind().is_list() {
+                    return;
+                }
+
+                self.parents.pop().unwrap();
+
+                // We're passed this node, flush any pending comments for its children
+                self.following_node_index = None;
+                self.flush_comments(None);
+
+                // We're passed this node, so it must precede the sibling that comes next.
+                self.preceding_node = Some(node);
+            }
+        }
+    }
+
+    fn visit_token(&mut self, token: SyntaxToken<Style::Language>) {
+        let mut comments_start = self.pending_comments.len();
+
+        // The index of the last trailing comment in `pending_comments`.
+        let mut trailing_end: Option<usize> = None;
+
+        // Number of lines before the next comment, token, or skipped token trivia
+        let mut lines_before = 0;
+
+        // Trailing comments are all `SameLine` comments EXCEPT if any is followed by a line break,
+        // a leading comment (that always have line breaks), or there's a line break before the token.
+        let mut position = CommentTextPosition::SameLine;
+
+        // Process the trailing trivia of the last token
+        if let Some(last_token) = self.last_token.take() {
+            for piece in last_token.trailing_trivia().pieces() {
+                if piece.is_newline() {
+                    lines_before += 1;
+                    // All comments following from here are own line comments
+                    position = CommentTextPosition::OwnLine;
+
+                    if trailing_end.is_none() {
+                        trailing_end = Some(self.pending_comments.len());
+                    }
+                } else if let Some(comment) = piece.as_comments() {
+                    self.queue_comment(DecoratedComment {
+                        enclosing: self.enclosing_node().clone(),
+                        preceding: self.preceding_node.clone(),
+                        following: None,
+                        following_token: token.clone(),
+                        lines_before,
+                        lines_after: 0, // Will be initialized after
+                        position,
+                        kind: Style::get_comment_kind(&comment),
+                        comment,
+                    });
+
+                    lines_before = 0;
+                }
+
+                if let Some(parens_source_range) = self
+                    .parentheses
+                    .r_paren_source_range(piece.text_range().end())
+                {
+                    self.flush_before_r_paren_comments(
+                        parens_source_range,
+                        &last_token,
+                        position,
+                        lines_before,
+                        comments_start,
+                        trailing_end,
+                    );
+
+                    lines_before = 0;
+                    position = CommentTextPosition::SameLine;
+                    comments_start = 0;
+                    trailing_end = None;
+                }
+            }
+        }
+
+        // Process the leading trivia of the current token. the trailing trivia is handled as part of the next token
+        for leading in token.leading_trivia().pieces() {
+            if leading.is_newline() {
+                lines_before += 1;
+                // All comments following from here are own line comments
+                position = CommentTextPosition::OwnLine;
+
+                if trailing_end.is_none() {
+                    trailing_end = Some(self.pending_comments.len());
+                }
+            } else if leading.is_skipped() {
+                self.builder.mark_has_skipped(&token);
+
+                lines_before = 0;
+                break;
+            } else if let Some(comment) = leading.as_comments() {
+                let kind = Style::get_comment_kind(&comment);
+
+                self.queue_comment(DecoratedComment {
+                    enclosing: self.enclosing_node().clone(),
+                    preceding: self.preceding_node.clone(),
+                    following: None,
+                    following_token: token.clone(),
+                    lines_before,
+                    lines_after: 0,
+                    position,
+                    kind,
+                    comment,
+                });
+
+                lines_before = 0;
+            }
+        }
+
+        let trailing_end = trailing_end.unwrap_or(self.pending_comments.len());
+
+        self.last_token = Some(token);
+
+        let mut comments = self.pending_comments[comments_start..]
+            .iter_mut()
+            .enumerate()
+            .peekable();
+
+        // Update the lines after of all comments as well as the positioning of end of line comments.
+        while let Some((index, comment)) = comments.next() {
+            // Update the position of all trailing comments to be end of line as we've seen a line break since.
+            if index < trailing_end && position.is_own_line() {
+                comment.position = CommentTextPosition::EndOfLine;
+            }
+
+            comment.lines_after = comments
+                .peek()
+                .map_or(lines_before, |(_, next)| next.lines_before);
+        }
+
+        // Set following node to `None` because it now becomes the enclosing node.
+        if let Some(following_node) = self.following_node() {
+            self.flush_comments(Some(&following_node.clone()));
+            self.following_node_index = None;
+
+            // The following node is only set after entering a node
+            // That means, following node is only set for the first token of a node.
+            // Unset preceding node if this is the first token because the preceding node belongs to the parent.
+            self.preceding_node = None;
+        }
+    }
+
+    fn enclosing_node(&self) -> &SyntaxNode<Style::Language> {
+        let element = match self.following_node_index {
+            None => self.parents.last(),
+            Some(index) if index == 0 => Some(&self.parents[0]),
+            Some(index) => Some(&self.parents[index - 1]),
+        };
+
+        element.expect("Expected enclosing nodes to at least contain the root node.")
+    }
+
+    fn following_node(&self) -> Option<&SyntaxNode<Style::Language>> {
+        self.following_node_index.map(|index| {
+            self.parents
+                .get(index)
+                .expect("Expected following node index to point to a valid parent node")
+        })
+    }
+
+    fn queue_comment(&mut self, comment: DecoratedComment<Style::Language>) {
+        self.pending_comments.push(comment);
+    }
+
+    fn flush_comments(&mut self, following: Option<&SyntaxNode<Style::Language>>) {
+        for mut comment in self.pending_comments.drain(..) {
+            comment.following = following.cloned();
+
+            let placement = self.style.place_comment(comment);
+            self.builder.add_comment(placement);
+        }
+    }
+
+    /// Processes comments appearing right before a `)` of a parenthesized expressions.
+    #[cold]
+    fn flush_before_r_paren_comments(
+        &mut self,
+        parens_source_range: TextRange,
+        last_token: &SyntaxToken<Style::Language>,
+        position: CommentTextPosition,
+        lines_before: u32,
+        start: usize,
+        trailing_end: Option<usize>,
+    ) {
+        let enclosing = self.enclosing_node().clone();
+
+        let trailing_end = trailing_end.unwrap_or(self.pending_comments.len());
+        let mut comments = self.pending_comments[start..]
+            .iter_mut()
+            .enumerate()
+            .peekable();
+
+        let parenthesized_node = self
+            .parentheses
+            .outer_most_parenthesized_node(last_token, parens_source_range);
+
+        // SAFETY: Safe, because the above loop at least returns the parent of the token. If this isn't the case,
+        // then it's likely that the source map is corrupted.
+        let preceding = parenthesized_node.expect("Last token to have a parent node.");
+
+        // Using the `enclosing` as default but it's mainly to satisfy Rust. The only case where it is used
+        // is if someone formats a Parenthesized expression as the root. Something we explicitly disallow
+        // in rome_js_formatter
+        let enclosing = preceding.parent().unwrap_or(enclosing);
+
+        // Update the lines after of all comments as well as the positioning of end of line comments.
+        while let Some((index, comment)) = comments.next() {
+            // Update the position of all trailing comments to be end of line as we've seen a line break since.
+            if index < trailing_end && position.is_own_line() {
+                comment.position = CommentTextPosition::EndOfLine;
+            }
+
+            comment.preceding = Some(preceding.clone());
+            comment.enclosing = enclosing.clone();
+            comment.lines_after = comments
+                .peek()
+                .map_or(lines_before, |(_, next)| next.lines_before);
+        }
+
+        self.flush_comments(None);
+    }
+}
+
+struct CommentsBuilder<L: Language> {
+    comments: CommentsMap<SyntaxElementKey, SourceComment<L>>,
+    skipped: FxHashSet<SyntaxElementKey>,
+}
+
+impl<L: Language> CommentsBuilder<L> {
+    fn add_comment(&mut self, placement: CommentPlacement<L>) {
+        match placement {
+            CommentPlacement::Leading { node, comment } => {
+                self.push_leading_comment(&node, comment);
+            }
+            CommentPlacement::Trailing { node, comment } => {
+                self.push_trailing_comment(&node, comment);
+            }
+            CommentPlacement::Dangling { node, comment } => {
+                self.push_dangling_comment(&node, comment)
+            }
+            CommentPlacement::Default(mut comment) => {
+                match comment.position {
+                    CommentTextPosition::EndOfLine => {
+                        match (comment.take_preceding_node(), comment.take_following_node()) {
+                            (Some(preceding), Some(_)) => {
+                                // Attach comments with both preceding and following node to the preceding
+                                // because there's a line break separating it from the following node.
+                                // ```javascript
+                                // a; // comment
+                                // b
+                                // ```
+                                self.push_trailing_comment(&preceding, comment);
+                            }
+                            (Some(preceding), None) => {
+                                self.push_trailing_comment(&preceding, comment);
+                            }
+                            (None, Some(following)) => {
+                                self.push_leading_comment(&following, comment);
+                            }
+                            (None, None) => {
+                                self.push_dangling_comment(
+                                    &comment.enclosing_node().clone(),
+                                    comment,
+                                );
+                            }
+                        }
+                    }
+                    CommentTextPosition::OwnLine => {
+                        match (comment.take_preceding_node(), comment.take_following_node()) {
+                            // Following always wins for a leading comment
+                            // ```javascript
+                            // a;
+                            // // comment
+                            // b
+                            // ```
+                            // attach the comment to the `b` expression statement
+                            (_, Some(following)) => {
+                                self.push_leading_comment(&following, comment);
+                            }
+                            (Some(preceding), None) => {
+                                self.push_trailing_comment(&preceding, comment);
+                            }
+                            (None, None) => {
+                                self.push_dangling_comment(
+                                    &comment.enclosing_node().clone(),
+                                    comment,
+                                );
+                            }
+                        }
+                    }
+                    CommentTextPosition::SameLine => {
+                        match (comment.take_preceding_node(), comment.take_following_node()) {
+                            (Some(preceding), Some(following)) => {
+                                // Only make it a trailing comment if it directly follows the preceding node but not if it is separated
+                                // by one or more tokens
+                                // ```javascript
+                                // a /* comment */ b;   //  Comment is a trailing comment
+                                // a, /* comment */ b;  // Comment should be a leading comment
+                                // ```
+                                if preceding.text_range().end()
+                                    == comment.piece().as_piece().token().text_range().end()
+                                {
+                                    self.push_trailing_comment(&preceding, comment);
+                                } else {
+                                    self.push_leading_comment(&following, comment);
+                                }
+                            }
+                            (Some(preceding), None) => {
+                                self.push_trailing_comment(&preceding, comment);
+                            }
+                            (None, Some(following)) => {
+                                self.push_leading_comment(&following, comment);
+                            }
+                            (None, None) => {
+                                self.push_dangling_comment(
+                                    &comment.enclosing_node().clone(),
+                                    comment,
+                                );
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    fn mark_has_skipped(&mut self, token: &SyntaxToken<L>) {
+        self.skipped.insert(token.key());
+    }
+
+    fn push_leading_comment(&mut self, node: &SyntaxNode<L>, comment: impl Into<SourceComment<L>>) {
+        self.comments.push_leading(node.key(), comment.into());
+    }
+
+    fn push_dangling_comment(
+        &mut self,
+        node: &SyntaxNode<L>,
+        comment: impl Into<SourceComment<L>>,
+    ) {
+        self.comments.push_dangling(node.key(), comment.into());
+    }
+
+    fn push_trailing_comment(
+        &mut self,
+        node: &SyntaxNode<L>,
+        comment: impl Into<SourceComment<L>>,
+    ) {
+        self.comments.push_trailing(node.key(), comment.into());
+    }
+
+    fn finish(
+        self,
+    ) -> (
+        CommentsMap<SyntaxElementKey, SourceComment<L>>,
+        FxHashSet<SyntaxElementKey>,
+    ) {
+        (self.comments, self.skipped)
+    }
+}
+
+impl<L: Language> Default for CommentsBuilder<L> {
+    fn default() -> Self {
+        Self {
+            comments: CommentsMap::new(),
+            skipped: FxHashSet::default(),
+        }
+    }
+}
+
+enum SourceParentheses<'a> {
+    Empty,
+    SourceMap {
+        map: &'a TransformSourceMap,
+        next: Option<DeletedRangeEntry<'a>>,
+        tail: DeletedRanges<'a>,
+    },
+}
+
+impl<'a> SourceParentheses<'a> {
+    fn from_source_map(source_map: Option<&'a TransformSourceMap>) -> Self {
+        match source_map {
+            None => Self::Empty,
+            Some(source_map) => {
+                let mut deleted = source_map.deleted_ranges();
+                SourceParentheses::SourceMap {
+                    map: source_map,
+                    next: deleted.next(),
+                    tail: deleted,
+                }
+            }
+        }
+    }
+
+    /// Returns the range of `node` including its parentheses if any. Otherwise returns the range as is
+    fn parenthesized_range<L: Language>(&self, node: &SyntaxNode<L>) -> TextRange {
+        match self {
+            SourceParentheses::Empty => node.text_trimmed_range(),
+            SourceParentheses::SourceMap { map, .. } => map.trimmed_source_range(node),
+        }
+    }
+
+    /// Tests if the next offset is at a position where the original source document used to have an `)`.
+    ///
+    /// Must be called with offsets in increasing order.
+    ///
+    /// Returns the source range of the `)` if there's any `)` in the deleted range at this offset. Returns `None` otherwise
+
+    fn r_paren_source_range(&mut self, offset: TextSize) -> Option<TextRange> {
+        match self {
+            SourceParentheses::Empty => None,
+            SourceParentheses::SourceMap { next, tail, .. } => {
+                while let Some(range) = next {
+                    #[allow(clippy::comparison_chain)]
+                    if range.transformed == offset {
+                        // A deleted range can contain multiple tokens. See if there's any `)` in the deleted
+                        // range and compute its source range.
+                        return range.text.find(')').map(|r_paren_position| {
+                            let start = range.source + TextSize::from(r_paren_position as u32);
+                            TextRange::at(start, TextSize::from(1))
+                        });
+                    } else if range.transformed > offset {
+                        return None;
+                    } else {
+                        *next = tail.next();
+                    }
+                }
+
+                None
+            }
+        }
+    }
+
+    /// Searches the outer most node that still is inside of the parentheses specified by the `parentheses_source_range`.
+    fn outer_most_parenthesized_node<L: Language>(
+        &self,
+        token: &SyntaxToken<L>,
+        parentheses_source_range: TextRange,
+    ) -> Option<SyntaxNode<L>> {
+        match self {
+            SourceParentheses::Empty => token.parent(),
+            SourceParentheses::SourceMap { map, .. } => {
+                debug_assert_eq!(&map.text()[parentheses_source_range], ")");
+
+                // How this works: We search the outer most node that, in the source document ends right after the `)`.
+                // The issue is, it is possible that multiple nodes end right after the `)`
+                //
+                // ```javascript
+                // !(
+                //     a
+                //     /* comment */
+                //  )
+                // ```
+                // The issue is, that in the transformed document, the `ReferenceIdentifier`, `IdentifierExpression`, `UnaryExpression`, and `ExpressionStatement`
+                // all end at the end position of `)`.
+                // However, not all the nodes start at the same position. That's why this code also tracks the start.
+                // We first find the closest node that directly ends at the position of the right paren. We then continue
+                // upwards to find the most outer node that starts at the same position as that node. (In this case,
+                // `ReferenceIdentifier` -> `IdentifierExpression`.
+                let mut start_offset = None;
+                let r_paren_source_end = parentheses_source_range.end();
+
+                let ancestors = token.ancestors().take_while(|node| {
+                    let source_range = self.parenthesized_range(node);
+
+                    if let Some(start) = start_offset {
+                        TextRange::new(start, r_paren_source_end).contains_range(source_range)
+                    } else if source_range.end() == r_paren_source_end {
+                        start_offset = Some(source_range.start());
+                        true
+                    } else {
+                        source_range.end() < r_paren_source_end
+                    }
+                });
+
+                ancestors.last()
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::comments::builder::CommentsBuilderVisitor;
+    use crate::comments::map::CommentsMap;
+    use crate::comments::CommentTextPosition;
+    use crate::{
+        CommentKind, CommentPlacement, CommentStyle, DecoratedComment, SourceComment, TextSize,
+        TransformSourceMap, TransformSourceMapBuilder,
+    };
+    use rome_js_parser::parse_module;
+    use rome_js_syntax::{
+        JsIdentifierExpression, JsLanguage, JsParameters, JsParenthesizedExpression,
+        JsPropertyObjectMember, JsReferenceIdentifier, JsShorthandPropertyObjectMember,
+        JsSyntaxKind, JsSyntaxNode, JsUnaryExpression,
+    };
+    use rome_rowan::syntax::SyntaxElementKey;
+    use rome_rowan::{AstNode, BatchMutation, SyntaxNode, SyntaxTriviaPieceComments, TextRange};
+    use std::cell::RefCell;
+
+    #[test]
+    fn leading_comment() {
+        let (root, decorated, comments) = extract_comments(
+            r#"const foo = {
+  a: 'a',
+  /* comment for this line */
+  b
+};"#,
+        );
+
+        assert_eq!(decorated.len(), 1);
+
+        let comment = decorated.last().unwrap();
+
+        assert_eq!(comment.position(), CommentTextPosition::OwnLine);
+        assert_eq!(comment.lines_before(), 1);
+        assert_eq!(comment.lines_after(), 1);
+        assert_eq!(
+            comment
+                .preceding_node()
+                .map(|node| node.text_trimmed().to_string())
+                .as_deref(),
+            Some("a: 'a'")
+        );
+        assert_eq!(
+            comment
+                .following_node()
+                .map(|node| node.text_trimmed().to_string())
+                .as_deref(),
+            Some("b")
+        );
+        assert_eq!(
+            comment.enclosing_node().kind(),
+            JsSyntaxKind::JS_OBJECT_EXPRESSION
+        );
+
+        let b = root
+            .descendants()
+            .find_map(JsShorthandPropertyObjectMember::cast)
+            .unwrap();
+
+        assert!(!comments.leading(&b.syntax().key()).is_empty());
+    }
+
+    #[test]
+    fn trailing_comment() {
+        let (root, decorated, comments) = extract_comments(
+            r#"const foo = {
+  a: 'a' /* comment for this line */,
+  b
+};"#,
+        );
+
+        assert_eq!(decorated.len(), 1);
+
+        let comment = decorated.last().unwrap();
+
+        assert_eq!(comment.position(), CommentTextPosition::SameLine);
+        assert_eq!(comment.lines_after(), 0);
+        assert_eq!(comment.lines_before(), 0);
+        assert_eq!(
+            comment
+                .preceding_node()
+                .map(|node| node.text_trimmed().to_string())
+                .as_deref(),
+            Some("a: 'a'")
+        );
+        assert_eq!(
+            comment
+                .following_node()
+                .map(|node| node.text_trimmed().to_string())
+                .as_deref(),
+            Some("b")
+        );
+        assert_eq!(
+            comment.enclosing_node().kind(),
+            JsSyntaxKind::JS_OBJECT_EXPRESSION
+        );
+
+        let a = root
+            .descendants()
+            .find_map(JsPropertyObjectMember::cast)
+            .unwrap();
+
+        assert!(!comments.trailing(&a.syntax().key()).is_empty());
+    }
+
+    #[test]
+    fn end_of_line_comment() {
+        let (root, decorated, comments) = extract_comments(
+            r#"const foo = {
+  a: 'a', /* comment for this line */
+  b
+};"#,
+        );
+
+        assert_eq!(decorated.len(), 1);
+
+        let comment = decorated.last().unwrap();
+
+        assert_eq!(comment.position(), CommentTextPosition::EndOfLine);
+        assert_eq!(comment.lines_before(), 0);
+        assert_eq!(comment.lines_after(), 1);
+        assert_eq!(
+            comment
+                .preceding_node()
+                .map(|node| node.text_trimmed().to_string())
+                .as_deref(),
+            Some("a: 'a'")
+        );
+        assert_eq!(
+            comment
+                .following_node()
+                .map(|node| node.text_trimmed().to_string())
+                .as_deref(),
+            Some("b")
+        );
+        assert_eq!(
+            comment.enclosing_node().kind(),
+            JsSyntaxKind::JS_OBJECT_EXPRESSION
+        );
+
+        let a = root
+            .descendants()
+            .find_map(JsPropertyObjectMember::cast)
+            .unwrap();
+
+        assert!(!comments.trailing(&a.syntax().key()).is_empty());
+    }
+
+    #[test]
+    fn dangling_arrow() {
+        let (root, decorated_comments, comments) = extract_comments("(/* comment */)  => true");
+
+        assert_eq!(decorated_comments.len(), 1);
+
+        let decorated = &decorated_comments[0];
+        assert_eq!(decorated.position(), CommentTextPosition::SameLine);
+        assert_eq!(decorated.lines_before(), 0);
+        assert_eq!(decorated.lines_after(), 0);
+        assert_eq!(decorated.preceding_node(), None);
+        assert_eq!(decorated.following_node(), None);
+        assert_eq!(
+            decorated.enclosing_node().kind(),
+            JsSyntaxKind::JS_PARAMETERS
+        );
+
+        let parameters = root.descendants().find_map(JsParameters::cast).unwrap();
+        assert!(!comments.dangling(&parameters.syntax().key()).is_empty());
+    }
+
+    #[test]
+    fn dangling_comments() {
+        let (root, decorated_comments, comments) = extract_comments(
+            r#"
+            function (/* test */) {}
+            "#,
+        );
+
+        assert_eq!(decorated_comments.len(), 1);
+
+        let decorated = &decorated_comments[0];
+        assert_eq!(decorated.position(), CommentTextPosition::SameLine);
+        assert_eq!(decorated.lines_before(), 0);
+        assert_eq!(decorated.lines_after(), 0);
+        assert_eq!(decorated.preceding_node(), None);
+        assert_eq!(decorated.following_node(), None);
+        assert_eq!(
+            decorated.enclosing_node().kind(),
+            JsSyntaxKind::JS_PARAMETERS
+        );
+
+        let parameters = root.descendants().find_map(JsParameters::cast).unwrap();
+        assert!(!comments.dangling(&parameters.syntax().key()).is_empty());
+    }
+
+    #[test]
+    fn r_paren() {
+        let source = r#"!(
+    a
+    /* comment */
+)
+/* comment */
+b;"#;
+
+        let mut source_map_builder = TransformSourceMapBuilder::with_source(source.to_string());
+        let l_paren_range = TextRange::new(TextSize::from(1), TextSize::from(2));
+        let r_paren_range = TextRange::new(TextSize::from(27), TextSize::from(28));
+
+        assert_eq!(&source[l_paren_range], "(");
+        assert_eq!(&source[r_paren_range], ")");
+
+        source_map_builder.add_deleted_range(l_paren_range);
+        source_map_builder.add_deleted_range(r_paren_range);
+        source_map_builder.extend_trimmed_node_range(
+            TextRange::new(TextSize::from(7), TextSize::from(8)),
+            TextRange::new(l_paren_range.start(), r_paren_range.end()),
+        );
+
+        let source_map = source_map_builder.finish();
+
+        let root = parse_module(source, 0).syntax();
+
+        // A lot of code that simply removes the parenthesized expression and moves the parens
+        // trivia to the identifiers leading / trailing trivia.
+        let parenthesized = root
+            .descendants()
+            .find_map(JsParenthesizedExpression::cast)
+            .unwrap();
+
+        let reference_identifier = root
+            .descendants()
+            .find_map(JsReferenceIdentifier::cast)
+            .unwrap();
+
+        let mut mutation = BatchMutation::new(root);
+
+        let identifier_expression =
+            JsIdentifierExpression::cast(parenthesized.expression().unwrap().into_syntax())
+                .unwrap();
+        let l_paren = parenthesized.l_paren_token().unwrap();
+        let r_paren = parenthesized.r_paren_token().unwrap();
+
+        let identifier_token = reference_identifier.value_token().unwrap();
+        let new_identifier_token = identifier_token
+            .with_leading_trivia_pieces(
+                l_paren
+                    .leading_trivia()
+                    .pieces()
+                    .chain(l_paren.trailing_trivia().pieces())
+                    .chain(identifier_token.leading_trivia().pieces())
+                    .collect::<Vec<_>>(),
+            )
+            .with_trailing_trivia_pieces(
+                identifier_token
+                    .trailing_trivia()
+                    .pieces()
+                    .chain(r_paren.leading_trivia().pieces())
+                    .chain(r_paren.trailing_trivia().pieces())
+                    .collect::<Vec<_>>(),
+            );
+
+        let new_reference_identifier = reference_identifier.with_value_token(new_identifier_token);
+
+        let new_identifier_expression = identifier_expression.with_name(new_reference_identifier);
+
+        mutation.replace_element_discard_trivia(
+            parenthesized.into_syntax().into(),
+            new_identifier_expression.into_syntax().into(),
+        );
+
+        let transformed = mutation.commit();
+
+        let style = TestCommentStyle::default();
+        let comments_builder = CommentsBuilderVisitor::new(&style, Some(&source_map));
+        let (comments, _) = comments_builder.visit(&transformed);
+
+        let decorated_comments = style.finish();
+
+        assert_eq!(decorated_comments.len(), 2);
+
+        let argument_trailing = &decorated_comments[0];
+        assert_eq!(argument_trailing.position(), CommentTextPosition::OwnLine);
+        assert_eq!(argument_trailing.lines_before(), 1);
+        assert_eq!(argument_trailing.lines_after(), 1);
+        assert_eq!(
+            argument_trailing
+                .preceding_node()
+                .map(|preceding| preceding.kind()),
+            Some(JsSyntaxKind::JS_IDENTIFIER_EXPRESSION)
+        );
+        assert_eq!(argument_trailing.following_node(), None);
+        assert_eq!(
+            argument_trailing.enclosing_node().kind(),
+            JsSyntaxKind::JS_UNARY_EXPRESSION
+        );
+
+        let identifier_leading = &decorated_comments[1];
+        assert_eq!(identifier_leading.position(), CommentTextPosition::OwnLine);
+        assert_eq!(identifier_leading.lines_before(), 1);
+        assert_eq!(identifier_leading.lines_after(), 1);
+        assert_eq!(
+            identifier_leading.preceding_node().map(SyntaxNode::kind),
+            Some(JsSyntaxKind::JS_EXPRESSION_STATEMENT)
+        );
+        assert_eq!(
+            identifier_leading.following_node().map(SyntaxNode::kind),
+            Some(JsSyntaxKind::JS_EXPRESSION_STATEMENT)
+        );
+        assert_eq!(
+            identifier_leading.enclosing_node().kind(),
+            JsSyntaxKind::JS_MODULE
+        );
+
+        let unary = transformed
+            .descendants()
+            .find_map(JsUnaryExpression::cast)
+            .unwrap();
+        assert!(!comments
+            .trailing(&unary.argument().unwrap().syntax().key())
+            .is_empty());
+    }
+
+    #[test]
+    fn comment_only_program() {
+        let (root, decorated, comments) = extract_comments(
+            r#"/* test */
+
+/* test */"#,
+        );
+
+        assert_eq!(decorated.len(), 2);
+
+        let first = &decorated[0];
+        assert_eq!(first.position(), CommentTextPosition::EndOfLine);
+        assert_eq!(first.lines_before(), 0);
+        assert_eq!(first.lines_after(), 2);
+        assert_eq!(first.preceding_node(), None);
+        assert_eq!(
+            first.following_node().map(SyntaxNode::kind),
+            Some(JsSyntaxKind::JS_MODULE)
+        );
+        assert_eq!(first.enclosing_node().kind(), JsSyntaxKind::JS_MODULE);
+
+        let second = &decorated[1];
+        assert_eq!(second.position(), CommentTextPosition::OwnLine);
+        assert_eq!(second.lines_before(), 2);
+        assert_eq!(second.lines_after(), 0);
+        assert_eq!(second.preceding_node(), None);
+        assert_eq!(
+            first.following_node().map(SyntaxNode::kind),
+            Some(JsSyntaxKind::JS_MODULE)
+        );
+        assert_eq!(second.enclosing_node().kind(), JsSyntaxKind::JS_MODULE);
+
+        assert!(!comments.leading(&root.key()).is_empty());
+    }
+
+    fn extract_comments(
+        source: &str,
+    ) -> (
+        JsSyntaxNode,
+        Vec<DecoratedComment<JsLanguage>>,
+        CommentsMap<SyntaxElementKey, SourceComment<JsLanguage>>,
+    ) {
+        extract_with_source_map(source, None)
+    }
+
+    fn extract_with_source_map(
+        source: &str,
+        source_map: Option<&TransformSourceMap>,
+    ) -> (
+        JsSyntaxNode,
+        Vec<DecoratedComment<JsLanguage>>,
+        CommentsMap<SyntaxElementKey, SourceComment<JsLanguage>>,
+    ) {
+        let tree = parse_module(source, 0);
+
+        let style = TestCommentStyle::default();
+        let builder = CommentsBuilderVisitor::new(&style, source_map);
+        let (comments, _) = builder.visit(&tree.syntax());
+
+        (tree.syntax(), style.finish(), comments)
+    }
+
+    #[derive(Default)]
+    struct TestCommentStyle {
+        recorded_comments: RefCell<Vec<DecoratedComment<JsLanguage>>>,
+    }
+
+    impl CommentStyle for TestCommentStyle {
+        type Language = JsLanguage;
+
+        fn is_suppression(_: &str) -> bool {
+            false
+        }
+
+        fn get_comment_kind(_: &SyntaxTriviaPieceComments<Self::Language>) -> CommentKind {
+            CommentKind::Block
+        }
+
+        fn place_comment(
+            &self,
+            comment: DecoratedComment<Self::Language>,
+        ) -> CommentPlacement<Self::Language> {
+            self.recorded_comments.borrow_mut().push(comment.clone());
+
+            CommentPlacement::Default(comment)
+        }
+    }
+
+    impl TestCommentStyle {
+        fn finish(self) -> Vec<DecoratedComment<JsLanguage>> {
+            self.recorded_comments.take()
+        }
+    }
+}
diff --git a/crates/rome_formatter/src/lib.rs b/crates/rome_formatter/src/lib.rs
index 3e3cc9a8510..d5e12a4353b 100644
--- a/crates/rome_formatter/src/lib.rs
+++ b/crates/rome_formatter/src/lib.rs
@@ -53,7 +53,10 @@ pub use builders::{
     if_group_fits_on_line, indent, labelled, line_suffix, soft_block_indent, soft_line_break,
     soft_line_break_or_space, soft_line_indent_or_space, space, text, BestFitting,
 };
-pub use comments::{CommentKind, CommentStyle, Comments, SourceComment};
+pub use comments::{
+    CommentKind, CommentPlacement, CommentStyle, CommentTextPosition, Comments, DecoratedComment,
+    SourceComment,
+};
 pub use format_element::{normalize_newlines, FormatElement, Text, Verbatim, LINE_TERMINATORS};
 pub use group_id::GroupId;
 use indexmap::IndexSet;
@@ -232,14 +235,10 @@ pub trait FormatOptions {
 /// The context customizes the comments formatting and stores the comments of the CST.
 pub trait CstFormatContext: FormatContext {
     type Language: Language;
-    type Style: CommentStyle<Self::Language>;
-
-    /// Rule for formatting leading comments.
-    type LeadingCommentRule: FormatRule<SourceComment<Self::Language>, Context = Self> + Default;
+    type Style: CommentStyle<Language = Self::Language>;
 
-    /// Customizes how comments are formatted
-    #[deprecated(note = "Prefer FormatLanguage::comment_style")]
-    fn comment_style(&self) -> Self::Style;
+    /// Rule for formatting comments.
+    type CommentRule: FormatRule<SourceComment<Self::Language>, Context = Self> + Default;
 
     /// Returns a reference to the program's comments.
     fn comments(&self) -> &Comments<Self::Language>;
@@ -825,14 +824,11 @@ pub trait FormatLanguage {
     type Context: CstFormatContext<Language = Self::SyntaxLanguage>;
 
     /// The type specifying how to format comments.
-    type CommentStyle: CommentStyle<Self::SyntaxLanguage>;
+    type CommentStyle: CommentStyle<Language = Self::SyntaxLanguage>;
 
     /// The rule type that can format a [SyntaxNode] of this language
     type FormatRule: FormatRule<SyntaxNode<Self::SyntaxLanguage>, Context = Self::Context> + Default;
 
-    /// Customizes how comments are formatted
-    fn comment_style(&self) -> Self::CommentStyle;
-
     /// Performs an optional pre-processing of the tree. This can be useful to remove nodes
     /// that otherwise complicate formatting.
     ///
@@ -877,7 +873,7 @@ pub fn format_node<L: FormatLanguage>(
             None => (root.clone(), None),
         };
 
-        let comments = Comments::from_node(&root, &language);
+        let comments = Comments::from_node(&root, &L::CommentStyle::default(), source_map.as_ref());
         let format_node = FormatRefWithRule::new(&root, L::FormatRule::default());
 
         let context = language.create_context(comments, source_map);

From 39abce792fec42244620befc7221462f571da76f Mon Sep 17 00:00:00 2001
From: Micha Reiser <micha@rome.tools>
Date: Fri, 16 Sep 2022 14:23:36 +0200
Subject: [PATCH 05/15] Document Comments API

---
 crates/rome_formatter/src/comments.rs         | 559 ++++++++++++++++--
 crates/rome_formatter/src/comments/builder.rs |  57 +-
 crates/rome_formatter/src/lib.rs              |   8 +-
 crates/rome_formatter/src/token.rs            |   6 +-
 4 files changed, 537 insertions(+), 93 deletions(-)

diff --git a/crates/rome_formatter/src/comments.rs b/crates/rome_formatter/src/comments.rs
index f022ae8bbee..ea6dd93e3a1 100644
--- a/crates/rome_formatter/src/comments.rs
+++ b/crates/rome_formatter/src/comments.rs
@@ -1,3 +1,80 @@
+//! Types for extracting and representing comments of a syntax tree.
+//!
+//! Most programming languages support comments allowing programmers to document their programs. Comments are different from other syntaxes  because programming languages allow comments in almost any position, giving programmers great flexibility on where they can write comments:
+//!
+//! ```ignore
+//! /**
+//!  * Documentation comment
+//!  */
+//! async /* comment */ function Test () // line comment
+//! {/*inline*/}
+//! ```
+//!
+//! However, this flexibility makes formatting comments challenging because:
+//! * The formatter must consistently place comments so that re-formatting the output yields the same result and does not create invalid syntax (line comments).
+//! * It is essential that formatters place comments close to the syntax the programmer intended to document. However, the lack of rules regarding where comments are allowed and what syntax they document requires the use of heuristics to infer the documented syntax.
+//!
+//! This module strikes a balance between placing comments as closely as possible to their source location and reducing the complexity of formatting comments. It does so by associating comments per node rather than a token. This greatly reduces the combinations of possible comment positions but turns out to be, in practice, sufficiently precise to keep comments close to their source location.
+//!
+//! ## Node comments
+//!
+//! Comments are associated per node but get further distinguished on their location related to that node:
+//!
+//! ### Leading Comments
+//!
+//! A comment at the start of a node
+//!
+//! ```ignore
+//! // Leading comment of the statement
+//! console.log("test");
+//!
+//! [/* leading comment of identifier */ a ];
+//! ```
+//!
+//! ### Dangling Comments
+//!
+//! A comment that is neither at the start nor the end of a node
+//!
+//! ```ignore
+//! [/* in between the brackets */ ];
+//! async  /* between keywords */  function Test () {}
+//! ```
+//!
+//! ### Trailing Comments
+//!
+//! A comment at the end of a node
+//!
+//! ```ignore
+//! [a /* trailing comment of a */, b, c];
+//! [
+//!     a // trailing comment of a
+//! ]
+//! ```
+//!
+//! ## Limitations
+//! Limiting the placement of comments to leading, dangling, or trailing node comments reduces complexity inside the formatter but means, that the formatter's possibility of where comments can be formatted depends on the AST structure.
+//!
+//! For example, the continue statement in JavaScript is defined as:
+//!
+//! ```ungram
+//! JsContinueStatement =
+//! 'continue'
+//! (label: 'ident')?
+//! ';'?
+//! ```
+//!
+//! but a programmer may decide to add a comment in front or after the label:
+//!
+//! ```ignore
+//! continue /* comment 1 */ label;
+//! continue label /* comment 2*/; /* trailing */
+//! ```
+//!
+//! Because all children of the `continue` statement are tokens, it is only possible to make the comments leading, dangling, or trailing comments of the `continue` statement. But this results in a loss of information as the formatting code can no longer distinguish if a comment appeared before or after the label and, thus, has to format them the same way.
+//!
+//! This hasn't shown to be a significant limitation today but the infrastructure could be extended to support a `label` on [`SourceComment`] that allows to further categorise comments.
+//!
+
 mod builder;
 mod map;
 
@@ -16,9 +93,7 @@ pub enum CommentKind {
     ///
     /// ## Examples
     ///
-    /// ### JavaScript:
-    ///
-    /// ```javascript
+    /// ```ignore
     /// a /* test */
     /// ```
     InlineBlock,
@@ -27,8 +102,6 @@ pub enum CommentKind {
     ///
     /// ## Examples
     ///
-    /// ### JavaScript
-    ///
     /// ```javascript
     /// /* first line
     ///  * more content on the second line
@@ -40,9 +113,7 @@ pub enum CommentKind {
     ///
     /// ## Examples
     ///
-    /// ### JavaScript
-    ///
-    /// ```javascript
+    /// ```ignore
     /// a // test
     /// ```
     Line,
@@ -66,7 +137,7 @@ impl CommentKind {
     /// ## Examples
     ///
     /// ```rust
-    /// use rome_formatter::CommentKind;
+    /// use rome_formatter::comments::CommentKind;
     ///
     /// // Block and InlineBlock comments can appear inline
     /// assert!(CommentKind::Block.is_inline());
@@ -80,6 +151,7 @@ impl CommentKind {
     }
 }
 
+/// A comment in the source document.
 #[derive(Debug, Clone)]
 pub struct SourceComment<L: Language> {
     /// The number of lines appearing before this comment
@@ -90,6 +162,7 @@ pub struct SourceComment<L: Language> {
     /// The comment piece
     pub(crate) piece: SyntaxTriviaPieceComments<L>,
 
+    /// The kind of the comment.
     pub(crate) kind: CommentKind,
 }
 
@@ -99,11 +172,53 @@ impl<L: Language> SourceComment<L> {
         &self.piece
     }
 
-    /// Returns the number of lines before directly before this comment
+    /// The number of lines between this comment and the **previous** token or comment.
+    ///
+    /// # Examples
+    ///
+    /// ## Same line
+    ///
+    /// ```ignore
+    /// a // end of line
+    /// ```
+    ///
+    /// Returns `0` because there's no line break between the token `a` and the comment.
+    ///
+    /// ## Own Line
+    ///
+    /// ```ignore
+    /// a;
+    ///
+    /// /* comment */
+    /// ```
+    ///
+    /// Returns `2` because there are two line breaks between the token `a` and the comment.
     pub fn lines_before(&self) -> u32 {
         self.lines_before
     }
 
+    /// The number of line breaks right after this comment.
+    ///
+    /// # Examples
+    ///
+    /// ## End of line
+    ///
+    /// ```ignore
+    /// a; // comment
+    ///
+    /// b;
+    /// ```
+    ///
+    /// Returns `2` because there are two line breaks between the comment and the token `b`.
+    ///
+    /// ## Same line
+    ///
+    /// ```ignore
+    /// a;
+    /// /* comment */ b;
+    /// ```
+    ///
+    /// Returns `0` because there are no line breaks between the comment and the token `b`.
     pub fn lines_after(&self) -> u32 {
         self.lines_after
     }
@@ -114,13 +229,16 @@ impl<L: Language> SourceComment<L> {
     }
 }
 
+/// A comment decorated with additional information about its surrounding context in the source document.
+///
+/// Used by [CommentStyle::place_comment] to determine if this should become a [leading](self#leading-comments), [dangling](self#dangling-comments), or [trailing](self#trailing-comments) comment.
 #[derive(Debug, Clone)]
 pub struct DecoratedComment<L: Language> {
     enclosing: SyntaxNode<L>,
     preceding: Option<SyntaxNode<L>>,
     following: Option<SyntaxNode<L>>,
     following_token: SyntaxToken<L>,
-    position: CommentTextPosition,
+    text_position: CommentTextPosition,
     lines_before: u32,
     lines_after: u32,
     comment: SyntaxTriviaPieceComments<L>,
@@ -128,53 +246,194 @@ pub struct DecoratedComment<L: Language> {
 }
 
 impl<L: Language> DecoratedComment<L> {
-    /// The node that fully encloses the comment (the comment's start and end position are fully in the
-    /// node's bounds).
+    /// The closest parent node that fully encloses the comment.
+    ///
+    /// A node encloses a comment when the comment is between two of its direct children (ignoring lists).
+    ///
+    /// # Examples
+    ///
+    /// ```ignore
+    /// [a, /* comment */ b]
+    /// ```
+    ///
+    /// The enclosing node is the array expression and not the identifier `b` because
+    /// `a` and `b` are children of the array expression and `comment` is a comment between the two nodes.
     pub fn enclosing_node(&self) -> &SyntaxNode<L> {
         &self.enclosing
     }
 
+    /// Returns the comment piece.
     pub fn piece(&self) -> &SyntaxTriviaPieceComments<L> {
         &self.comment
     }
 
-    /// The node directly preceding the comment or [None] if the comment is preceded by a token or is the first
-    /// token in the program.
+    /// Returns the node preceding the comment.
+    ///
+    /// The direct child node (ignoring lists) of the [`enclosing_node`](DecoratedComment::enclosing_node) that precedes this comment.
+    ///
+    /// Returns [None] if the [`enclosing_node`](DecoratedComment::enclosing_node) only consists of tokens or if
+    /// all preceding children of the [`enclosing_node`](DecoratedComment::enclosing_node) have been tokens.
+    ///
+    /// The Preceding node is guaranteed to be a sibling of [`following_node`](DecoratedComment::following_node).
+    ///
+    /// # Examples
+    ///
+    /// ## Preceding tokens only
+    ///
+    /// ```ignore
+    /// [/* comment */]
+    /// ```
+    /// Returns [None] because the comment has no preceding node, only a preceding `[` token.
+    ///
+    /// ## Preceding node
+    ///
+    /// ```ignore
+    /// [a /* comment */, b]
+    /// ```
+    ///
+    /// Returns `Some(a)` because `a` directly precedes the comment.
+    ///
+    /// ## Preceding token and node
+    ///
+    /// ```ignore
+    /// [a, /* comment */]
+    /// ```
+    ///
+    ///  Returns `Some(a)` because `a` is the preceding node of `comment`. The presence of the `,` token
+    /// doesn't change that.
     pub fn preceding_node(&self) -> Option<&SyntaxNode<L>> {
         self.preceding.as_ref()
     }
 
+    /// Takes the [`preceding_node`](DecoratedComment::preceding_node) and replaces it with [None].
     fn take_preceding_node(&mut self) -> Option<SyntaxNode<L>> {
         self.preceding.take()
     }
 
-    /// The node directly following the comment or [None] if the comment is followed by a token or is the last token in the program.
+    /// Returns the node following the comment.
+    ///
+    /// The direct child node (ignoring lists) of the [`enclosing_node`](DecoratedComment::enclosing_node) that follows this comment.
+    ///
+    /// Returns [None] if the [`enclosing_node`](DecoratedComment::enclosing_node) only consists of tokens or if
+    /// all children children of the [`enclosing_node`](DecoratedComment::enclosing_node) following this comment are tokens.
+    ///
+    /// The following node is guaranteed to be a sibling of [`preceding_node`](DecoratedComment::preceding_node).
+    ///
+    /// # Examples
+    ///
+    /// ## Following tokens only
+    ///
+    /// ```ignore
+    /// [ /* comment */ ]
+    /// ```
+    ///
+    /// Returns [None] because there's no node following the comment, only the `]` token.
+    ///
+    /// ## Following node
+    ///
+    /// ```ignore
+    /// [ /* comment */ a ]
+    /// ```
+    ///
+    /// Returns `Some(a)` because `a` is the node directly following the comment.
+    ///
+    /// ## Following token and node
+    ///
+    /// ```ignore
+    /// async /* comment */ function test() {}
+    /// ```
+    ///
+    /// Returns `Some(test)` because the `test` identifier is the first node following `comment`.
+    ///
+    /// ## Following parenthesized expression
+    ///
+    /// ```ignore
+    /// !(
+    ///     a /* comment */
+    /// );
+    /// b
+    /// ```
+    ///
+    /// Returns `None` because `comment` is enclosed inside the parenthesized expression and it has no children
+    /// following `/* comment */.
     pub fn following_node(&self) -> Option<&SyntaxNode<L>> {
         self.following.as_ref()
     }
 
+    /// Takes the [`following_node`](DecoratedComment::following_node) and replaces it with [None].
     fn take_following_node(&mut self) -> Option<SyntaxNode<L>> {
         self.following.take()
     }
 
-    /// The number of lines between this comment and the **previous** token, comment or skipped trivia.
+    /// The number of lines between this comment and the **previous** token or comment.
+    ///
+    /// # Examples
+    ///
+    /// ## Same line
+    ///
+    /// ```ignore
+    /// a // end of line
+    /// ```
+    ///
+    /// Returns `0` because there's no line break between the token `a` and the comment.
+    ///
+    /// ## Own Line
+    ///
+    /// ```ignore
+    /// a;
+    ///
+    /// /* comment */
+    /// ```
+    ///
+    /// Returns `2` because there are two line breaks between the token `a` and the comment.
     pub fn lines_before(&self) -> u32 {
         self.lines_before
     }
 
+    /// The number of line breaks right after this comment.
+    ///
+    /// # Examples
+    ///
+    /// ## End of line
+    ///
+    /// ```ignore
+    /// a; // comment
+    ///
+    /// b;
+    /// ```
+    ///
+    /// Returns `2` because there are two line breaks between the comment and the token `b`.
+    ///
+    /// ## Same line
+    ///
+    /// ```ignore
+    /// a;
+    /// /* comment */ b;
+    /// ```
+    ///
+    /// Returns `0` because there are no line breaks between the comment and the token `b`.
     pub fn lines_after(&self) -> u32 {
         self.lines_after
     }
 
-    /// Returns the [kind](CommentKind) of the comment.
+    /// Returns the [CommentKind] of the comment.
     pub fn kind(&self) -> CommentKind {
         self.kind
     }
 
-    pub fn position(&self) -> CommentTextPosition {
-        self.position
+    /// The position of the comment in the text.
+    pub fn text_position(&self) -> CommentTextPosition {
+        self.text_position
     }
 
+    /// The next token that comes after this comment. It is possible that other comments are between this comment
+    /// and the token.
+    ///
+    /// ```ignore
+    /// a /* comment */ /* other b */
+    /// ```
+    ///
+    /// The `following_token` for both comments is `b` because it's the token coming after the comments.
     pub fn following_token(&self) -> &SyntaxToken<L> {
         &self.following_token
     }
@@ -191,28 +450,53 @@ impl<L: Language> From<DecoratedComment<L>> for SourceComment<L> {
     }
 }
 
-/// The position of a comment in the source document.
+/// The position of a comment in the source text.
 #[derive(Debug, Copy, Clone, Eq, PartialEq)]
 pub enum CommentTextPosition {
-    /// A comment that is separated by at least one line break from the following token
+    /// A comment that is on the same line as the preceding token and is separated by at least one line break from the following token.
     ///
-    /// ```javascript
+    /// # Examples
+    ///
+    /// ## End of line
+    ///
+    /// ```ignore
     /// a; /* this */ // or this
     /// b;
+    /// ```
+    ///
+    /// Both `/* this */` and `// or this` are end of line comments because both comments are separated by
+    /// at least one line break from the following token `b`.
+    ///
+    /// ## Own line
+    ///
+    /// ```ignore
+    /// a;
+    /// /* comment */
+    /// b;
+    /// ```
+    ///
+    /// This is not an end of line comment because it isn't on the same line as the preceding token `a`.
     EndOfLine,
 
-    /// A Comment that is separated by at least one line break from the preceding token
+    /// A Comment that is separated by at least one line break from the preceding token.
     ///
-    /// ```javascript
+    /// # Examples
+    ///
+    /// ```ignore
     /// a;
     /// /* comment */ /* or this */
     /// b;
     /// ```
+    ///
+    /// Both comments are own line comments because they are separated by one line break from the preceding
+    /// token `a`.
     OwnLine,
 
     /// A comment that is placed on the same line as the preceding and following token.
     ///
-    /// ```javascript
+    /// # Examples
+    ///
+    /// ```ignore
     /// a /* comment */ + b
     /// ```
     SameLine,
@@ -234,29 +518,190 @@ impl CommentTextPosition {
 
 #[derive(Debug)]
 pub enum CommentPlacement<L: Language> {
-    /// Overrides the positioning of the comment to be a leading node comment.
+    /// Makes `comment` a [leading comment](self#leading-comments) of `node`.
     Leading {
         node: SyntaxNode<L>,
         comment: SourceComment<L>,
     },
-    /// Overrides the positioning of the comment to be a trailing node comment.
+    /// Makes `comment` a [trailing comment](self#trailing-comments) of `node`.
     Trailing {
         node: SyntaxNode<L>,
         comment: SourceComment<L>,
     },
 
-    /// Makes this comment a dangling comment of `node`
+    /// Makes `comment` a [dangling comment](self#dangling-comments) of `node`.
     Dangling {
         node: SyntaxNode<L>,
         comment: SourceComment<L>,
     },
 
-    /// Uses the default positioning rules for the comment.
-    /// TODO document rules
+    /// Uses the default heuristic to determine the placement of the comment.
+    ///
+    /// # Same line comments
+    ///
+    /// Makes the comment a...
+    ///
+    /// * [trailing comment] of the [`preceding_node`] if both the [`following_node`] and [`preceding_node`] are not [None]
+    ///     and the comment and [`preceding_node`] are only separated by a space (there's no token between the comment and [`preceding_node`]).
+    /// * [leading comment] of the [`following_node`] if the [`following_node`] is not [None]
+    /// * [trailing comment] of the [`preceding_node`] if the [`preceding_node`] is not [None]
+    /// * [dangling comment] of the [`enclosing_node`].
+    ///
+    /// ## Examples
+    /// ### Comment with preceding and following nodes
+    ///
+    /// ```ignore
+    /// [
+    ///     a, // comment
+    ///     b
+    /// ]
+    /// ```
+    ///
+    /// The comment becomes a [trailing comment] of the node `a`.
+    ///
+    /// ### Comment with preceding node only
+    ///
+    /// ```ignore
+    /// [
+    ///     a // comment
+    /// ]
+    /// ```
+    ///
+    /// The comment becomes a [trailing comment] of the node `a`.
+    ///
+    /// ### Comment with following node only
+    ///
+    /// ```ignore
+    /// [ // comment
+    ///     b
+    /// ]
+    /// ```
+    ///
+    /// The comment becomes a [leading comment] of the node `b`.
+    ///
+    /// ### Dangling comment
+    ///
+    /// ```ignore
+    /// [ // comment
+    /// ]
+    /// ```
+    ///
+    /// The comment becomes a [dangling comment] of the enclosing array expression because both the [`preceding_node`] and [`following_node`] are [None].
+    ///
+    /// # Own line comments
+    ///
+    /// Makes the comment a...
+    ///
+    /// * [leading comment] of the [`following_node`] if the [`following_node`] is not [None]
+    /// * or a [trailing comment] of the [`preceding_node`] if the [`preceding_node`] is not [None]
+    /// * or a [dangling comment] of the [`enclosing_node`].
+    ///
+    /// ## Examples
+    ///
+    /// ### Comment with leading and preceding nodes
+    ///
+    /// ```ignore
+    /// [
+    ///     a,
+    ///     // comment
+    ///     b
+    /// ]
+    /// ```
+    ///
+    /// The comment becomes a [leading comment] of the node `b`.
+    ///
+    /// ### Comment with preceding node only
+    ///
+    /// ```ignore
+    /// [
+    ///     a
+    ///     // comment
+    /// ]
+    /// ```
+    ///
+    /// The comment becomes a [trailing comment] of the node `a`.
+    ///
+    /// ### Comment with following node only
+    ///
+    /// ```ignore
+    /// [
+    ///     // comment
+    ///     b
+    /// ]
+    /// ```
+    ///
+    /// The comment becomes a [leading comment] of the node `b`.
+    ///
+    /// ### Dangling comment
+    ///
+    /// ```ignore
+    /// [
+    ///     // comment
+    /// ]
+    /// ```
+    ///
+    /// The comment becomes a [dangling comment] of the array expression because both [`preceding_node`] and [`following_node`] are [None].
+    ///
+    ///
+    /// # End of line comments
+    /// Makes the comment a...
+    ///
+    /// * [trailing comment] of the [`preceding_node`] if the [`preceding_node`] is not [None]
+    /// * or a [leading comment] of the [`following_node`] if the [`following_node`] is not [None]
+    /// * or a [dangling comment] of the [`enclosing_node`].
+    ///
+    ///
+    /// ## Examples
+    ///
+    /// ### Comment with leading and preceding nodes
+    ///
+    /// ```ignore
+    /// [a /* comment */, b]
+    /// ```
+    ///
+    /// The comment becomes a [trailing comment] of the node `a` because there's no token between the node `a` and the `comment`.
+    ///
+    /// ```ignore
+    /// [a, /* comment */ b]
+    /// ```
+    ///
+    /// The comment becomes a [leading comment] of the node `b` because the node `a` and the comment are separated by a `,` token.
+    ///
+    /// ### Comment with preceding node only
+    ///
+    /// ```ignore
+    /// [a, /* last */ ]
+    /// ```
+    ///
+    /// The comment becomes a [trailing comment] of the node `a` because the [`following_node`] is [None].
+    ///
+    /// ### Comment with following node only
+    ///
+    /// ```ignore
+    /// [/* comment */ b]
+    /// ```
+    ///
+    /// The comment becomes a [leading comment] of the node `b` because the [`preceding_node`] is [None]
+    ///
+    /// ### Dangling comment
+    ///
+    /// ```ignore
+    /// [/* comment*/]
+    /// ```
+    ///
+    /// The comment becomes a [dangling comment] of the array expression because both [`preceding_node`] and [`following_node`] are [None].
+    ///
+    /// [`preceding_node`]: DecoratedComment::preceding_node
+    /// [`following_node`]: DecoratedComment::following_node
+    /// [`enclosing_node`]: DecoratedComment::enclosing_node
+    /// [trailing comment]: self#trailing-comments
+    /// [leading comment]: self#leading-comments
+    /// [dangling comment]: self#dangling-comments
     Default(DecoratedComment<L>),
 }
 
 impl<L: Language> CommentPlacement<L> {
+    /// Makes `comment` a [leading comment](self#leading-comments) of `node`.
     #[inline]
     pub fn leading(node: SyntaxNode<L>, comment: impl Into<SourceComment<L>>) -> Self {
         Self::Leading {
@@ -265,6 +710,7 @@ impl<L: Language> CommentPlacement<L> {
         }
     }
 
+    /// Makes `comment` a [dangling comment](self::dangling-comments) of `node`.
     pub fn dangling(node: SyntaxNode<L>, comment: impl Into<SourceComment<L>>) -> Self {
         Self::Dangling {
             node,
@@ -272,6 +718,7 @@ impl<L: Language> CommentPlacement<L> {
         }
     }
 
+    /// Makes `comment` a [trailing comment](self::trailing-comments) of `node`.
     #[inline]
     pub fn trailing(node: SyntaxNode<L>, comment: impl Into<SourceComment<L>>) -> Self {
         Self::Trailing {
@@ -280,13 +727,14 @@ impl<L: Language> CommentPlacement<L> {
         }
     }
 
+    /// Returns the placement if it isn't [CommentPlacement::Default], otherwise calls `f` and returns the result.
     #[inline]
-    pub fn or_else<F>(self, or_else: F) -> Self
+    pub fn or_else<F>(self, f: F) -> Self
     where
         F: FnOnce(DecoratedComment<L>) -> CommentPlacement<L>,
     {
         match self {
-            CommentPlacement::Default(comment) => or_else(comment),
+            CommentPlacement::Default(comment) => f(comment),
             placement => placement,
         }
     }
@@ -304,6 +752,9 @@ pub trait CommentStyle: Default {
     /// Returns the (kind)[CommentKind] of the comment
     fn get_comment_kind(comment: &SyntaxTriviaPieceComments<Self::Language>) -> CommentKind;
 
+    /// Determines the placement of `comment`.
+    ///
+    /// The default implementation returns [CommentPlacement::Default].
     fn place_comment(
         &self,
         comment: DecoratedComment<Self::Language>,
@@ -312,11 +763,7 @@ pub trait CommentStyle: Default {
     }
 }
 
-/// Type that stores the comments of a tree and gives access to:
-///
-/// * whether a node should be formatted as is because it has a leading suppression comment.
-/// * a node's leading and trailing comments
-/// * the dangling comments of a token
+/// The comments of a syntax tree stored by node.
 ///
 /// Cloning `comments` is cheap as it only involves bumping a reference counter.
 #[derive(Debug, Clone, Default)]
@@ -340,7 +787,7 @@ pub struct Comments<L: Language> {
 }
 
 impl<L: Language> Comments<L> {
-    /// Extracts all the suppressions from `root` and its child nodes.
+    /// Extracts all the comments from `root` and its descendants nodes.
     pub fn from_node<Style>(
         root: &SyntaxNode<L>,
         style: &Style,
@@ -366,66 +813,63 @@ impl<L: Language> Comments<L> {
         }
     }
 
-    /// Returns `true` if the given `node` has any leading or trailing comments.
+    /// Returns `true` if the given `node` has any [leading](self#leading-comments) or [trailing](self#trailing-comments) comments.
     #[inline]
     pub fn has_comments(&self, node: &SyntaxNode<L>) -> bool {
         self.data.comments.has(&node.key())
     }
 
-    /// Returns `true` if the given [node] has any leading comments.
-    /// By default, a comment is a node's leading comment if:
-    /// * the previous sibling is a token
-    /// * there's a line break before the commend ending before this comment and the comment.
+    /// Returns `true` if the given `node` has any [leading comments](self#leading-comments).
     #[inline]
     pub fn has_leading_comments(&self, node: &SyntaxNode<L>) -> bool {
         !self.leading_comments(node).is_empty()
     }
 
-    /// Tests if the node has any leading comment that will be placed on its own line.
+    /// Tests if the node has any [leading comments](self#leading-comments) that have a leading line break.
+    ///
+    /// Corresponds to [CommentTextPosition::OwnLine].
     pub fn has_leading_own_line_comment(&self, node: &SyntaxNode<L>) -> bool {
         self.leading_comments(node)
             .iter()
             .any(|comment| comment.lines_after() > 0)
     }
 
-    /// Returns the [node]'s leading comments.
+    /// Returns the `node`'s [leading comments](self#leading-comments).
     #[inline]
     pub fn leading_comments(&self, node: &SyntaxNode<L>) -> &[SourceComment<L>] {
         self.data.comments.leading(&node.key())
     }
 
-    /// Returns `true` if node has any dangling comments.
+    /// Returns `true` if node has any [dangling comments](self#dangling-comments).
     pub fn has_dangling_comments(&self, node: &SyntaxNode<L>) -> bool {
         !self.dangling_comments(node).is_empty()
     }
 
-    /// Returns the dangling comments of `node`
+    /// Returns the [dangling comments](self#dangling-comments) of `node`
     pub fn dangling_comments(&self, node: &SyntaxNode<L>) -> &[SourceComment<L>] {
         self.data.comments.dangling(&node.key())
     }
 
-    /// Returns the [node]'s trailing comments.
+    /// Returns the `node`'s [trailing comments](self#trailing-comments).
     #[inline]
     pub fn trailing_comments(&self, node: &SyntaxNode<L>) -> &[SourceComment<L>] {
         self.data.comments.trailing(&node.key())
     }
 
+    /// Returns `true` if the node has any [trailing](self#trailing-comments) [line](CommentKind::Line) comment.
     pub fn has_trailing_line_comment(&self, node: &SyntaxNode<L>) -> bool {
         self.trailing_comments(node)
             .iter()
             .any(|comment| comment.kind().is_line())
     }
 
-    /// Returns `true` if the given [node] has any trailing comments.
-    /// By default, a comment is a node's trailing comment if:
-    /// * the next sibling is a token
-    /// * there's **no** line break between the node and this comment.
+    /// Returns `true` if the given `node` has any [trailing comments](self#trailing-comments).
     #[inline]
     pub fn has_trailing_comments(&self, node: &SyntaxNode<L>) -> bool {
         !self.trailing_comments(node).is_empty()
     }
 
-    /// Returns an iterator over the leading and trailing comments of `node`.
+    /// Returns an iterator over the [leading](self#leading-comments) and [trailing comments](self#trailing-comments) of `node`.
     pub fn leading_trailing_comments(
         &self,
         node: &SyntaxNode<L>,
@@ -435,7 +879,7 @@ impl<L: Language> Comments<L> {
             .chain(self.trailing_comments(node).iter())
     }
 
-    /// Returns an iterator over the leading, dangling, and trailing comments of `node`.
+    /// Returns an iterator over the [leading](self#leading-comments), [dangling](self#dangling-comments), and [trailing](self#trailing) comments of `node`.
     pub fn leading_dangling_trailing_comments<'a>(
         &'a self,
         node: &'a SyntaxNode<L>,
@@ -449,10 +893,7 @@ impl<L: Language> Comments<L> {
         self.data.with_skipped.contains(&token.key())
     }
 
-    /// Returns `true` if the passed `node` has a leading suppression comment.
-    ///
-    /// Suppression comments only apply if they at the start of a node and they suppress the most
-    /// outer node.
+    /// Returns `true` if `node` has a [leading](self#leading-comments), [dangling](self#dangling-comments), or [trailing](self#trailing-comments) suppression comment.
     ///
     /// # Examples
     ///
diff --git a/crates/rome_formatter/src/comments/builder.rs b/crates/rome_formatter/src/comments/builder.rs
index c7484535e07..e666f779631 100644
--- a/crates/rome_formatter/src/comments/builder.rs
+++ b/crates/rome_formatter/src/comments/builder.rs
@@ -1,16 +1,16 @@
-use crate::comments::map::CommentsMap;
-use crate::comments::CommentTextPosition;
-use crate::source_map::{DeletedRangeEntry, DeletedRanges};
-use crate::{
-    CommentPlacement, CommentStyle, DecoratedComment, SourceComment, TextRange, TextSize,
-    TransformSourceMap,
+use super::{
+    map::CommentsMap, CommentPlacement, CommentStyle, CommentTextPosition, DecoratedComment,
+    SourceComment, TransformSourceMap,
 };
+use crate::source_map::{DeletedRangeEntry, DeletedRanges};
+use crate::{TextRange, TextSize};
 use rome_rowan::syntax::SyntaxElementKey;
 use rome_rowan::{
     Direction, Language, SyntaxElement, SyntaxKind, SyntaxNode, SyntaxToken, WalkEvent,
 };
 use rustc_hash::FxHashSet;
 
+/// Extracts all comments from a syntax tree.
 pub(super) struct CommentsBuilderVisitor<'a, Style: CommentStyle> {
     builder: CommentsBuilder<Style::Language>,
     style: &'a Style,
@@ -147,7 +147,7 @@ where
                         following_token: token.clone(),
                         lines_before,
                         lines_after: 0, // Will be initialized after
-                        position,
+                        text_position: position,
                         kind: Style::get_comment_kind(&comment),
                         comment,
                     });
@@ -201,7 +201,7 @@ where
                     following_token: token.clone(),
                     lines_before,
                     lines_after: 0,
-                    position,
+                    text_position: position,
                     kind,
                     comment,
                 });
@@ -223,7 +223,7 @@ where
         while let Some((index, comment)) = comments.next() {
             // Update the position of all trailing comments to be end of line as we've seen a line break since.
             if index < trailing_end && position.is_own_line() {
-                comment.position = CommentTextPosition::EndOfLine;
+                comment.text_position = CommentTextPosition::EndOfLine;
             }
 
             comment.lines_after = comments
@@ -310,7 +310,7 @@ where
         while let Some((index, comment)) = comments.next() {
             // Update the position of all trailing comments to be end of line as we've seen a line break since.
             if index < trailing_end && position.is_own_line() {
-                comment.position = CommentTextPosition::EndOfLine;
+                comment.text_position = CommentTextPosition::EndOfLine;
             }
 
             comment.preceding = Some(preceding.clone());
@@ -342,7 +342,7 @@ impl<L: Language> CommentsBuilder<L> {
                 self.push_dangling_comment(&node, comment)
             }
             CommentPlacement::Default(mut comment) => {
-                match comment.position {
+                match comment.text_position {
                     CommentTextPosition::EndOfLine => {
                         match (comment.take_preceding_node(), comment.take_following_node()) {
                             (Some(preceding), Some(_)) => {
@@ -583,13 +583,12 @@ impl<'a> SourceParentheses<'a> {
 
 #[cfg(test)]
 mod tests {
-    use crate::comments::builder::CommentsBuilderVisitor;
-    use crate::comments::map::CommentsMap;
-    use crate::comments::CommentTextPosition;
-    use crate::{
-        CommentKind, CommentPlacement, CommentStyle, DecoratedComment, SourceComment, TextSize,
-        TransformSourceMap, TransformSourceMapBuilder,
+    use super::CommentsBuilderVisitor;
+    use crate::comments::{
+        CommentKind, CommentPlacement, CommentStyle, CommentTextPosition, CommentsMap,
+        DecoratedComment, SourceComment,
     };
+    use crate::{TextSize, TransformSourceMap, TransformSourceMapBuilder};
     use rome_js_parser::parse_module;
     use rome_js_syntax::{
         JsIdentifierExpression, JsLanguage, JsParameters, JsParenthesizedExpression,
@@ -614,7 +613,7 @@ mod tests {
 
         let comment = decorated.last().unwrap();
 
-        assert_eq!(comment.position(), CommentTextPosition::OwnLine);
+        assert_eq!(comment.text_position(), CommentTextPosition::OwnLine);
         assert_eq!(comment.lines_before(), 1);
         assert_eq!(comment.lines_after(), 1);
         assert_eq!(
@@ -657,7 +656,7 @@ mod tests {
 
         let comment = decorated.last().unwrap();
 
-        assert_eq!(comment.position(), CommentTextPosition::SameLine);
+        assert_eq!(comment.text_position(), CommentTextPosition::SameLine);
         assert_eq!(comment.lines_after(), 0);
         assert_eq!(comment.lines_before(), 0);
         assert_eq!(
@@ -700,7 +699,7 @@ mod tests {
 
         let comment = decorated.last().unwrap();
 
-        assert_eq!(comment.position(), CommentTextPosition::EndOfLine);
+        assert_eq!(comment.text_position(), CommentTextPosition::EndOfLine);
         assert_eq!(comment.lines_before(), 0);
         assert_eq!(comment.lines_after(), 1);
         assert_eq!(
@@ -737,7 +736,7 @@ mod tests {
         assert_eq!(decorated_comments.len(), 1);
 
         let decorated = &decorated_comments[0];
-        assert_eq!(decorated.position(), CommentTextPosition::SameLine);
+        assert_eq!(decorated.text_position(), CommentTextPosition::SameLine);
         assert_eq!(decorated.lines_before(), 0);
         assert_eq!(decorated.lines_after(), 0);
         assert_eq!(decorated.preceding_node(), None);
@@ -762,7 +761,7 @@ mod tests {
         assert_eq!(decorated_comments.len(), 1);
 
         let decorated = &decorated_comments[0];
-        assert_eq!(decorated.position(), CommentTextPosition::SameLine);
+        assert_eq!(decorated.text_position(), CommentTextPosition::SameLine);
         assert_eq!(decorated.lines_before(), 0);
         assert_eq!(decorated.lines_after(), 0);
         assert_eq!(decorated.preceding_node(), None);
@@ -862,7 +861,10 @@ b;"#;
         assert_eq!(decorated_comments.len(), 2);
 
         let argument_trailing = &decorated_comments[0];
-        assert_eq!(argument_trailing.position(), CommentTextPosition::OwnLine);
+        assert_eq!(
+            argument_trailing.text_position(),
+            CommentTextPosition::OwnLine
+        );
         assert_eq!(argument_trailing.lines_before(), 1);
         assert_eq!(argument_trailing.lines_after(), 1);
         assert_eq!(
@@ -878,7 +880,10 @@ b;"#;
         );
 
         let identifier_leading = &decorated_comments[1];
-        assert_eq!(identifier_leading.position(), CommentTextPosition::OwnLine);
+        assert_eq!(
+            identifier_leading.text_position(),
+            CommentTextPosition::OwnLine
+        );
         assert_eq!(identifier_leading.lines_before(), 1);
         assert_eq!(identifier_leading.lines_after(), 1);
         assert_eq!(
@@ -914,7 +919,7 @@ b;"#;
         assert_eq!(decorated.len(), 2);
 
         let first = &decorated[0];
-        assert_eq!(first.position(), CommentTextPosition::EndOfLine);
+        assert_eq!(first.text_position(), CommentTextPosition::EndOfLine);
         assert_eq!(first.lines_before(), 0);
         assert_eq!(first.lines_after(), 2);
         assert_eq!(first.preceding_node(), None);
@@ -925,7 +930,7 @@ b;"#;
         assert_eq!(first.enclosing_node().kind(), JsSyntaxKind::JS_MODULE);
 
         let second = &decorated[1];
-        assert_eq!(second.position(), CommentTextPosition::OwnLine);
+        assert_eq!(second.text_position(), CommentTextPosition::OwnLine);
         assert_eq!(second.lines_before(), 2);
         assert_eq!(second.lines_after(), 0);
         assert_eq!(second.preceding_node(), None);
diff --git a/crates/rome_formatter/src/lib.rs b/crates/rome_formatter/src/lib.rs
index d5e12a4353b..498dff1f674 100644
--- a/crates/rome_formatter/src/lib.rs
+++ b/crates/rome_formatter/src/lib.rs
@@ -24,7 +24,7 @@
 mod arguments;
 mod buffer;
 mod builders;
-mod comments;
+pub mod comments;
 pub mod format_element;
 mod format_extensions;
 pub mod formatter;
@@ -53,10 +53,8 @@ pub use builders::{
     if_group_fits_on_line, indent, labelled, line_suffix, soft_block_indent, soft_line_break,
     soft_line_break_or_space, soft_line_indent_or_space, space, text, BestFitting,
 };
-pub use comments::{
-    CommentKind, CommentPlacement, CommentStyle, CommentTextPosition, Comments, DecoratedComment,
-    SourceComment,
-};
+
+use crate::comments::{CommentStyle, Comments, SourceComment};
 pub use format_element::{normalize_newlines, FormatElement, Text, Verbatim, LINE_TERMINATORS};
 pub use group_id::GroupId;
 use indexmap::IndexSet;
diff --git a/crates/rome_formatter/src/token.rs b/crates/rome_formatter/src/token.rs
index 680c89c9503..04d8fdfb3d9 100644
--- a/crates/rome_formatter/src/token.rs
+++ b/crates/rome_formatter/src/token.rs
@@ -1,8 +1,8 @@
-use crate::comments::CommentStyle;
+use crate::comments::{CommentKind, CommentStyle, SourceComment};
 use crate::prelude::*;
 use crate::{
-    format_args, write, Argument, Arguments, CommentKind, CstFormatContext, FormatRefWithRule,
-    GroupId, LastTokenKind, SourceComment,
+    format_args, write, Argument, Arguments, CstFormatContext, FormatRefWithRule, GroupId,
+    LastTokenKind,
 };
 use rome_rowan::{Language, SyntaxToken, SyntaxTriviaPiece};
 

From 884e258cccc8de9423cd14276a58237eb852be15 Mon Sep 17 00:00:00 2001
From: Micha Reiser <micha@rome.tools>
Date: Thu, 15 Sep 2022 13:40:16 +0200
Subject: [PATCH 06/15] refactor(rome_formatter): Delete
 `FormatElement::Comment`

This PR removes the `FormatElement::Comment` element. It was used to this point because the `group` builder had to move `comments` outside of the start/end of the group.

No such inspection is necessary after the refactor which is why the element can be deleted.
---
 crates/rome_formatter/src/builders.rs       | 67 ---------------------
 crates/rome_formatter/src/format_element.rs | 15 +----
 crates/rome_formatter/src/lib.rs            |  2 +-
 3 files changed, 3 insertions(+), 81 deletions(-)

diff --git a/crates/rome_formatter/src/builders.rs b/crates/rome_formatter/src/builders.rs
index 7fef20d8a04..2d262d7a739 100644
--- a/crates/rome_formatter/src/builders.rs
+++ b/crates/rome_formatter/src/builders.rs
@@ -457,73 +457,6 @@ impl<Context> Format<Context> for LineSuffixBoundary {
     }
 }
 
-/// Marks some content as a comment trivia.
-///
-/// This does not directly influence how this content will be printed, but some
-/// parts of the formatter may chose to handle this element in a specific way
-///
-/// ## Examples
-///
-/// ```
-/// use rome_formatter::{format, write, format_args};
-/// use rome_formatter::prelude::*;
-///
-/// let elements = format!(
-///     SimpleFormatContext::default(),
-///     [
-///         group(&format_args![
-///             comment(&format_args![text("// test"), hard_line_break()]),
-///             format_with(|f| {
-///                 write!(f, [
-///                     comment(&format_args![text("/* inline */"), hard_line_break()]).memoized(),
-///                     text("a"),
-///                     soft_line_break_or_space(),
-///                 ])
-///             }).memoized(),
-///             text("b"),
-///             soft_line_break_or_space(),
-///             text("c")
-///         ])
-///     ]
-/// ).unwrap();
-///
-/// assert_eq!(
-///     "// test\n/* inline */\na b c",
-///     elements.print().as_code()
-/// );
-/// ```
-#[inline]
-pub fn comment<Content, Context>(content: &Content) -> FormatComment<Context>
-where
-    Content: Format<Context>,
-{
-    FormatComment {
-        content: Argument::new(content),
-    }
-}
-
-#[derive(Copy, Clone)]
-pub struct FormatComment<'a, Context> {
-    content: Argument<'a, Context>,
-}
-
-impl<Context> Format<Context> for FormatComment<'_, Context> {
-    fn fmt(&self, f: &mut Formatter<Context>) -> FormatResult<()> {
-        let mut buffer = VecBuffer::new(f.state_mut());
-
-        buffer.write_fmt(Arguments::from(&self.content))?;
-        let content = buffer.into_vec();
-
-        f.write_element(FormatElement::Comment(content.into_boxed_slice()))
-    }
-}
-
-impl<Context> std::fmt::Debug for FormatComment<'_, Context> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_tuple("Comment").field(&"{{content}}").finish()
-    }
-}
-
 /// Marks some content with a label.
 ///
 /// This does not directly influence how this content will be printed, but some
diff --git a/crates/rome_formatter/src/format_element.rs b/crates/rome_formatter/src/format_element.rs
index c2a1b566aff..79c3c57cc0e 100644
--- a/crates/rome_formatter/src/format_element.rs
+++ b/crates/rome_formatter/src/format_element.rs
@@ -81,12 +81,6 @@ pub enum FormatElement {
     /// line suffixes, potentially by inserting a hard line break.
     LineSuffixBoundary,
 
-    /// Special semantic element letting the printer and formatter know this is
-    /// a comment content, and it should only have a limited influence on the
-    /// formatting (for instance line breaks contained within will not cause
-    /// the parent group to break if this element is at the start of it).
-    Comment(Box<[FormatElement]>),
-
     /// A token that tracks tokens/nodes that are printed as verbatim.
     Verbatim(Verbatim),
 
@@ -193,7 +187,6 @@ impl std::fmt::Debug for FormatElement {
                 fmt.debug_tuple("LineSuffix").field(content).finish()
             }
             FormatElement::LineSuffixBoundary => write!(fmt, "LineSuffixBoundary"),
-            FormatElement::Comment(content) => fmt.debug_tuple("Comment").field(content).finish(),
             FormatElement::Verbatim(verbatim) => fmt
                 .debug_tuple("Verbatim")
                 .field(&verbatim.content)
@@ -675,7 +668,6 @@ impl FormatElement {
             FormatElement::Group(Group { content, .. })
             | FormatElement::ConditionalGroupContent(ConditionalGroupContent { content, .. })
             | FormatElement::IndentIfGroupBreaks(IndentIfGroupBreaks { content, .. })
-            | FormatElement::Comment(content)
             | FormatElement::Fill(content)
             | FormatElement::Verbatim(Verbatim { content, .. })
             | FormatElement::Label(Label { content, .. })
@@ -705,13 +697,13 @@ impl FormatElement {
 
     /// Utility function to get the "last element" of a [FormatElement], recursing
     /// into lists and groups to find the last element that's not
-    /// a line break, or a comment.
+    /// a line break
     pub fn last_element(&self) -> Option<&FormatElement> {
         match self {
             FormatElement::List(list) => {
                 list.iter().rev().find_map(|element| element.last_element())
             }
-            FormatElement::Line(_) | FormatElement::Comment(_) => None,
+            FormatElement::Line(_) => None,
 
             FormatElement::Group(Group { content, .. }) | FormatElement::Indent(content) => {
                 content.iter().rev().find_map(FormatElement::last_element)
@@ -863,9 +855,6 @@ impl Format<IrFormatContext> for FormatElement {
             FormatElement::LineSuffix(line_suffix) => {
                 write!(f, [text("line_suffix("), line_suffix.as_ref(), text(")")])
             }
-            FormatElement::Comment(content) => {
-                write!(f, [text("comment("), content.as_ref(), text(")")])
-            }
             FormatElement::Verbatim(verbatim) => {
                 write!(f, [text("verbatim("), verbatim.content.as_ref(), text(")")])
             }
diff --git a/crates/rome_formatter/src/lib.rs b/crates/rome_formatter/src/lib.rs
index 498dff1f674..ff9bf3178ec 100644
--- a/crates/rome_formatter/src/lib.rs
+++ b/crates/rome_formatter/src/lib.rs
@@ -49,7 +49,7 @@ use crate::printer::{Printer, PrinterOptions};
 pub use arguments::{Argument, Arguments};
 pub use buffer::{Buffer, BufferExtensions, BufferSnapshot, Inspect, PreambleBuffer, VecBuffer};
 pub use builders::{
-    block_indent, comment, empty_line, get_lines_before, group, hard_line_break, if_group_breaks,
+    block_indent, empty_line, get_lines_before, group, hard_line_break, if_group_breaks,
     if_group_fits_on_line, indent, labelled, line_suffix, soft_block_indent, soft_line_break,
     soft_line_break_or_space, soft_line_indent_or_space, space, text, BestFitting,
 };

From a9f9ef42b49e5707bdea242bfbb0988b65e21811 Mon Sep 17 00:00:00 2001
From: Micha Reiser <micha@rome.tools>
Date: Thu, 15 Sep 2022 13:43:22 +0200
Subject: [PATCH 07/15] refactor(rome_formatter): Move verbatim formatting to
 `rome_formatter`

This PR moves the logic for formatting a node as `verbatim` to `rome_formatter` as it isn't JS specific
---
 crates/rome_formatter/src/lib.rs         |   2 +-
 crates/rome_formatter/src/verbatim.rs    | 173 +++++++
 crates/rome_js_formatter/src/builders.rs | 552 +----------------------
 crates/rome_js_formatter/src/lib.rs      |   2 +-
 4 files changed, 179 insertions(+), 550 deletions(-)
 create mode 100644 crates/rome_formatter/src/verbatim.rs

diff --git a/crates/rome_formatter/src/lib.rs b/crates/rome_formatter/src/lib.rs
index ff9bf3178ec..f8258fdad59 100644
--- a/crates/rome_formatter/src/lib.rs
+++ b/crates/rome_formatter/src/lib.rs
@@ -36,7 +36,7 @@ pub mod prelude;
 pub mod printed_tokens;
 pub mod printer;
 mod source_map;
-pub mod token;
+mod verbatim;
 
 use crate::formatter::Formatter;
 use crate::group_id::UniqueGroupIdBuilder;
diff --git a/crates/rome_formatter/src/verbatim.rs b/crates/rome_formatter/src/verbatim.rs
new file mode 100644
index 00000000000..dcf35785335
--- /dev/null
+++ b/crates/rome_formatter/src/verbatim.rs
@@ -0,0 +1,173 @@
+use crate::cst::{FormatLeadingComments, FormatTrailingComments};
+use crate::prelude::*;
+use crate::VecBuffer;
+use crate::{write, CstFormatContext};
+use rome_rowan::{Direction, Language, SyntaxElement, SyntaxNode, TextRange};
+
+/// "Formats" a node according to its original formatting in the source text. Being able to format
+/// a node "as is" is useful if a node contains syntax errors. Formatting a node with syntax errors
+/// has the risk that Rome misinterprets the structure of the code and formatting it could
+/// "mess up" the developers, yet incomplete, work or accidentally introduce new syntax errors.
+///
+/// You may be inclined to call `node.text` directly. However, using `text` doesn't track the nodes
+/// nor its children source mapping information, resulting in incorrect source maps for this subtree.
+///
+/// These nodes and tokens get tracked as [FormatElement::Verbatim], useful to understand
+/// if these nodes still need to have their own implementation.
+pub fn format_verbatim_node<L: Language>(node: &SyntaxNode<L>) -> FormatVerbatimNode<L> {
+    FormatVerbatimNode {
+        node,
+        kind: VerbatimKind::Verbatim {
+            length: node.text_range().len(),
+        },
+        format_comments: true,
+    }
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq)]
+pub struct FormatVerbatimNode<'node, L: Language> {
+    node: &'node SyntaxNode<L>,
+    kind: VerbatimKind,
+    format_comments: bool,
+}
+
+impl<Context> Format<Context> for FormatVerbatimNode<'_, Context::Language>
+where
+    Context: CstFormatContext,
+{
+    fn fmt(&self, f: &mut Formatter<Context>) -> FormatResult<()> {
+        for element in self.node.descendants_with_tokens(Direction::Next) {
+            match element {
+                SyntaxElement::Token(token) => f.state_mut().track_token(&token),
+                SyntaxElement::Node(node) => {
+                    f.context().comments().mark_suppression_checked(&node);
+                }
+            }
+        }
+
+        // The trimmed range of a node is its range without any of its leading or trailing trivia.
+        // Except for nodes that used to be parenthesized, the range than covers the source from the
+        // `(` to the `)` (the trimmed range of the parenthesized expression, not the inner expression)
+        let trimmed_source_range = f.context().source_map().map_or_else(
+            || self.node.text_trimmed_range(),
+            |source_map| source_map.trimmed_source_range(self.node),
+        );
+
+        let mut buffer = VecBuffer::new(f.state_mut());
+
+        write!(
+            buffer,
+            [format_with(|f: &mut Formatter<Context>| {
+                fn source_range<Context>(f: &Formatter<Context>, range: TextRange) -> TextRange
+                where
+                    Context: CstFormatContext,
+                {
+                    f.context()
+                        .source_map()
+                        .map_or_else(|| range, |source_map| source_map.source_range(range))
+                }
+
+                // Format all leading comments that are outside of the node's source range.
+                if self.format_comments {
+                    let comments = f.context().comments().clone();
+                    let leading_comments = comments.leading_comments(self.node);
+
+                    let outside_trimmed_range = leading_comments.partition_point(|comment| {
+                        comment.piece().text_range().end() <= trimmed_source_range.start()
+                    });
+
+                    write!(
+                        f,
+                        [FormatLeadingComments::Comments(
+                            &leading_comments[..outside_trimmed_range]
+                        )]
+                    )?;
+                }
+
+                // Find the first skipped token trivia, if any, and include it in the verbatim range because
+                // the comments only format **up to** but not including skipped token trivia.
+                let start_source = self
+                    .node
+                    .first_leading_trivia()
+                    .into_iter()
+                    .flat_map(|trivia| trivia.pieces())
+                    .filter(|trivia| trivia.is_skipped())
+                    .map(|trivia| source_range(f, trivia.text_range()).start())
+                    .take_while(|start| *start < trimmed_source_range.start())
+                    .next()
+                    .unwrap_or_else(|| trimmed_source_range.start());
+
+                let original_source = f.context().source_map().map_or_else(
+                    || self.node.text_trimmed().to_string(),
+                    |source_map| {
+                        source_map.text()[trimmed_source_range.cover_offset(start_source)]
+                            .to_string()
+                    },
+                );
+
+                dynamic_text(
+                    &normalize_newlines(&original_source, LINE_TERMINATORS),
+                    self.node.text_trimmed_range().start(),
+                )
+                .fmt(f)?;
+
+                // Format all trailing comments that are outside of the trimmed range.
+                if self.format_comments {
+                    let comments = f.context().comments().clone();
+
+                    let trailing_comments = comments.trailing_comments(self.node);
+
+                    let outside_trimmed_range_start =
+                        trailing_comments.partition_point(|comment| {
+                            source_range(f, comment.piece().text_range()).end()
+                                <= trimmed_source_range.end()
+                        });
+
+                    write!(
+                        f,
+                        [FormatTrailingComments::Comments(
+                            &trailing_comments[outside_trimmed_range_start..]
+                        )]
+                    )?;
+                }
+
+                Ok(())
+            })]
+        )?;
+
+        let content = buffer.into_vec();
+
+        let verbatim = Verbatim {
+            content: content.into_boxed_slice(),
+            kind: self.kind,
+        };
+
+        f.write_element(FormatElement::Verbatim(verbatim))
+    }
+}
+
+impl<L: Language> FormatVerbatimNode<'_, L> {
+    pub fn skip_comments(mut self) -> Self {
+        self.format_comments = false;
+        self
+    }
+}
+
+/// Formats unknown nodes. The difference between this method  and `format_verbatim` is that this method
+/// doesn't track nodes/tokens as [FormatElement::Verbatim]. They are just printed as they are.
+pub fn format_unknown_node<L: Language>(node: &SyntaxNode<L>) -> FormatVerbatimNode<L> {
+    FormatVerbatimNode {
+        node,
+        kind: VerbatimKind::Unknown,
+        format_comments: true,
+    }
+}
+
+/// Format a node having formatter suppression comment applied to it
+pub fn format_suppressed_node<L: Language>(node: &SyntaxNode<L>) -> FormatVerbatimNode<L> {
+    FormatVerbatimNode {
+        node,
+        kind: VerbatimKind::Suppressed,
+        format_comments: true,
+    }
+}
diff --git a/crates/rome_js_formatter/src/builders.rs b/crates/rome_js_formatter/src/builders.rs
index a25bd449673..8b3d5a05f91 100644
--- a/crates/rome_js_formatter/src/builders.rs
+++ b/crates/rome_js_formatter/src/builders.rs
@@ -1,12 +1,7 @@
 use crate::prelude::*;
 use crate::AsFormat;
-use rome_formatter::token::{FormatInserted, FormatInsertedCloseParen, FormatInsertedOpenParen};
-use rome_formatter::{
-    format_args, write, Argument, Arguments, CstFormatContext, FormatContext, GroupId,
-    PreambleBuffer, VecBuffer,
-};
-use rome_js_syntax::{JsLanguage, JsSyntaxKind, JsSyntaxNode, JsSyntaxToken};
-use rome_rowan::{AstNode, Direction, Language, SyntaxElement, SyntaxTriviaPiece, TextRange};
+use rome_js_syntax::JsLanguage;
+use rome_rowan::AstNode;
 
 /// Formats a node using its [`AsFormat`] implementation but falls back to printing the node as
 /// it is in the source document if the formatting returns an [`FormatError`].
@@ -36,549 +31,10 @@ where
             Err(_) => {
                 f.restore_state_snapshot(snapshot);
 
-                // Lists that yield errors are formatted as they were unknown nodes.
+                // Lists that yield errors are formatted as they were suppressed nodes.
                 // Doing so, the formatter formats the nodes/tokens as is.
-                format_unknown_node(self.node.syntax()).fmt(f)
+                format_suppressed_node(self.node.syntax()).fmt(f)
             }
         }
     }
 }
-
-pub fn format_inserted(kind: JsSyntaxKind) -> FormatInserted<JsLanguage> {
-    FormatInserted::new(
-        kind,
-        kind.to_string().expect("Expected a punctuation token"),
-    )
-}
-
-pub fn format_inserted_open_paren(
-    before_token: Option<&JsSyntaxToken>,
-    kind: JsSyntaxKind,
-) -> FormatInsertedOpenParen<JsLanguage> {
-    FormatInsertedOpenParen::new(
-        before_token,
-        kind,
-        kind.to_string()
-            .expect("Expected a punctuation token as the open paren token."),
-    )
-}
-
-pub fn format_inserted_close_paren(
-    after_token: Option<&JsSyntaxToken>,
-    kind: JsSyntaxKind,
-    f: &mut JsFormatter,
-) -> FormatInsertedCloseParen<JsLanguage> {
-    FormatInsertedCloseParen::after_token(
-        after_token,
-        kind,
-        kind.to_string()
-            .expect("Expected a punctuation token as the close paren token."),
-        f,
-    )
-}
-
-/// Adds parentheses around some content
-/// Ensures that the leading trivia of the `first_content_token` is moved
-/// before the opening parentheses and the trailing trivia of the `last_content_token`
-/// is moved after the closing parentheses.
-///
-/// # Examples
-/// Adding parentheses around the string literal
-///
-/// ```javascript
-/// /* leading */ "test" /* trailing */;
-/// ```
-///
-/// becomes
-///
-/// ```javascript
-/// /* leading */ ("test") /* trailing */;
-/// ```
-pub fn format_parenthesize<'a, Content>(
-    first_content_token: Option<&'a JsSyntaxToken>,
-    content: &'a Content,
-    last_content_token: Option<&'a JsSyntaxToken>,
-) -> FormatParenthesize<'a>
-where
-    Content: Format<JsFormatContext>,
-{
-    FormatParenthesize {
-        first_content_token,
-        content: Argument::new(content),
-        last_content_token,
-        grouped: false,
-    }
-}
-
-/// Adds parentheses around an expression
-#[derive(Clone)]
-pub struct FormatParenthesize<'a> {
-    grouped: bool,
-    first_content_token: Option<&'a JsSyntaxToken>,
-    content: Argument<'a, JsFormatContext>,
-    last_content_token: Option<&'a JsSyntaxToken>,
-}
-
-impl FormatParenthesize<'_> {
-    /// Groups the open parenthesis, the content, and the closing parenthesis inside of a group
-    /// and indents the content with a soft block indent.
-    pub fn grouped_with_soft_block_indent(mut self) -> Self {
-        self.grouped = true;
-        self
-    }
-}
-
-impl Format<JsFormatContext> for FormatParenthesize<'_> {
-    fn fmt(&self, f: &mut Formatter<JsFormatContext>) -> FormatResult<()> {
-        let format_open_paren =
-            format_inserted_open_paren(self.first_content_token, JsSyntaxKind::L_PAREN);
-        let format_close_paren =
-            format_inserted_close_paren(self.last_content_token, JsSyntaxKind::R_PAREN, f);
-
-        if self.grouped {
-            write!(
-                f,
-                [group(&format_args![
-                    format_open_paren,
-                    soft_block_indent(&Arguments::from(&self.content)),
-                    format_close_paren
-                ])]
-            )
-        } else {
-            write!(
-                f,
-                [
-                    format_open_paren,
-                    Arguments::from(&self.content),
-                    format_close_paren
-                ]
-            )
-        }
-    }
-}
-
-/// "Formats" a node according to its original formatting in the source text. Being able to format
-/// a node "as is" is useful if a node contains syntax errors. Formatting a node with syntax errors
-/// has the risk that Rome misinterprets the structure of the code and formatting it could
-/// "mess up" the developers, yet incomplete, work or accidentally introduce new syntax errors.
-///
-/// You may be inclined to call `node.text` directly. However, using `text` doesn't track the nodes
-/// nor its children source mapping information, resulting in incorrect source maps for this subtree.
-///
-/// These nodes and tokens get tracked as [FormatElement::Verbatim], useful to understand
-/// if these nodes still need to have their own implementation.
-pub fn format_verbatim_node(node: &JsSyntaxNode) -> FormatVerbatimNode {
-    FormatVerbatimNode {
-        node,
-        kind: VerbatimKind::Verbatim {
-            length: node.text_range().len(),
-        },
-    }
-}
-
-#[derive(Debug, Clone, Copy, Eq, PartialEq)]
-pub struct FormatVerbatimNode<'node> {
-    node: &'node JsSyntaxNode,
-    kind: VerbatimKind,
-}
-impl Format<JsFormatContext> for FormatVerbatimNode<'_> {
-    fn fmt(&self, f: &mut JsFormatter) -> FormatResult<()> {
-        for element in self.node.descendants_with_tokens(Direction::Next) {
-            match element {
-                SyntaxElement::Token(token) => f.state_mut().track_token(&token),
-                SyntaxElement::Node(node) => {
-                    f.context().comments().mark_suppression_checked(&node);
-                }
-            }
-        }
-
-        fn skip_whitespace<L: Language>(piece: &SyntaxTriviaPiece<L>) -> bool {
-            piece.is_newline() || piece.is_whitespace()
-        }
-
-        fn write_trivia_token<L: Language>(
-            f: &mut JsFormatter,
-            piece: SyntaxTriviaPiece<L>,
-        ) -> FormatResult<()> {
-            syntax_token_cow_slice(
-                normalize_newlines(piece.text(), LINE_TERMINATORS),
-                &piece.token(),
-                piece.text_range().start(),
-            )
-            .fmt(f)
-        }
-
-        let trimmed_source_range = f.context().source_map().map_or_else(
-            || self.node.text_trimmed_range(),
-            |source_map| source_map.trimmed_source_range(self.node),
-        );
-
-        let mut buffer = VecBuffer::new(f.state_mut());
-
-        write!(
-            buffer,
-            [format_with(|f: &mut JsFormatter| {
-                fn source_range(f: &JsFormatter, range: TextRange) -> TextRange {
-                    f.context()
-                        .source_map()
-                        .map_or_else(|| range, |source_map| source_map.source_range(range))
-                }
-
-                for leading_trivia in self
-                    .node
-                    .first_leading_trivia()
-                    .into_iter()
-                    .flat_map(|trivia| trivia.pieces())
-                    .skip_while(skip_whitespace)
-                {
-                    let trivia_source_range = source_range(f, leading_trivia.text_range());
-
-                    if trivia_source_range.start() >= trimmed_source_range.start() {
-                        break;
-                    }
-
-                    write_trivia_token(f, leading_trivia)?;
-                }
-
-                let original_source = f.context().source_map().map_or_else(
-                    || self.node.text_trimmed().to_string(),
-                    |source_map| source_map.text()[trimmed_source_range].to_string(),
-                );
-
-                dynamic_text(
-                    &normalize_newlines(&original_source, LINE_TERMINATORS),
-                    self.node.text_trimmed_range().start(),
-                )
-                .fmt(f)?;
-
-                let mut trailing_trivia = self
-                    .node
-                    .last_trailing_trivia()
-                    .into_iter()
-                    .flat_map(|trivia| trivia.pieces());
-
-                let mut trailing_back = trailing_trivia.by_ref().rev().peekable();
-
-                while let Some(trailing) = trailing_back.peek() {
-                    let is_whitespace = skip_whitespace(trailing);
-
-                    let trailing_source_range = source_range(f, trailing.text_range());
-                    let is_in_trimmed_range =
-                        trailing_source_range.start() < trimmed_source_range.end();
-
-                    if is_whitespace || is_in_trimmed_range {
-                        trailing_back.next();
-                    } else {
-                        break;
-                    }
-                }
-
-                for trailing_trivia in trailing_trivia {
-                    write_trivia_token(f, trailing_trivia)?;
-                }
-
-                Ok(())
-            })]
-        )?;
-
-        let content = buffer.into_vec();
-
-        let verbatim = Verbatim {
-            content: content.into_boxed_slice(),
-            kind: self.kind,
-        };
-
-        f.write_element(FormatElement::Verbatim(verbatim))
-    }
-}
-
-/// Formats unknown nodes. The difference between this method  and `format_verbatim` is that this method
-/// doesn't track nodes/tokens as [FormatElement::Verbatim]. They are just printed as they are.
-pub fn format_unknown_node(node: &JsSyntaxNode) -> FormatUnknownNode {
-    FormatUnknownNode { node }
-}
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub struct FormatUnknownNode<'node> {
-    node: &'node JsSyntaxNode,
-}
-
-impl Format<JsFormatContext> for FormatUnknownNode<'_> {
-    fn fmt(&self, f: &mut JsFormatter) -> FormatResult<()> {
-        FormatVerbatimNode {
-            node: self.node,
-            kind: VerbatimKind::Unknown,
-        }
-        .fmt(f)
-    }
-}
-
-/// Format a node having formatter suppression comment applied to it
-pub fn format_suppressed_node(node: &JsSyntaxNode) -> FormatSuppressedNode {
-    FormatSuppressedNode { node }
-}
-
-#[derive(Debug, Clone)]
-pub struct FormatSuppressedNode<'node> {
-    node: &'node JsSyntaxNode,
-}
-
-impl Format<JsFormatContext> for FormatSuppressedNode<'_> {
-    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!(
-            f,
-            [
-                hard_line_break(),
-                FormatVerbatimNode {
-                    node: self.node,
-                    kind: VerbatimKind::Suppressed
-                }
-            ]
-        )
-    }
-}
-
-/// Formats a group delimited by an opening and closing token,
-/// such as a function body delimited by '{' and '}' tokens
-///
-/// 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 fn format_delimited<'a, 'content>(
-    open_token: &'a JsSyntaxToken,
-    content: &'content impl Format<JsFormatContext>,
-    close_token: &'a JsSyntaxToken,
-) -> FormatDelimited<'a, 'content> {
-    FormatDelimited {
-        open_token,
-        content: Argument::new(content),
-        close_token,
-        mode: DelimitedMode::SoftBlockIndent(None),
-        grouped: true,
-    }
-}
-
-#[derive(Copy, Clone)]
-pub struct FormatDelimited<'a, 'content> {
-    open_token: &'a JsSyntaxToken,
-    content: Argument<'content, JsFormatContext>,
-    close_token: &'a JsSyntaxToken,
-    mode: DelimitedMode,
-    grouped: bool,
-}
-
-impl FormatDelimited<'_, '_> {
-    fn with_mode(mut self, mode: DelimitedMode) -> Self {
-        self.mode = mode;
-        self
-    }
-
-    /// Formats a group delimited by an opening and closing token, placing the
-    /// content in a [block_indent] group
-    pub fn block_indent(self) -> Self {
-        self.with_mode(DelimitedMode::BlockIndent)
-    }
-
-    /// Formats a group delimited by an opening and closing token, placing the
-    /// content in a [soft_block_indent] group
-    pub fn soft_block_indent(self) -> Self {
-        self.with_mode(DelimitedMode::SoftBlockIndent(None))
-    }
-
-    /// Formats a group delimited by an opening and closing token, placing the
-    /// content in an [indent] group with [soft_line_break_or_space] tokens at the
-    /// start and end
-    pub fn soft_block_spaces(self) -> Self {
-        self.with_mode(DelimitedMode::SoftBlockSpaces(None))
-    }
-
-    pub fn soft_block_indent_with_group_id(self, group_id: Option<GroupId>) -> Self {
-        self.with_mode(DelimitedMode::SoftBlockIndent(group_id))
-    }
-
-    /// Prevents the formatter from grouping the content even in soft block or soft block spaces mode.
-    pub fn ungrouped(mut self) -> Self {
-        self.grouped = false;
-        self
-    }
-}
-
-impl Format<JsFormatContext> for FormatDelimited<'_, '_> {
-    fn fmt(&self, f: &mut JsFormatter) -> FormatResult<()> {
-        let FormatDelimited {
-            open_token,
-            close_token,
-            content,
-            mode,
-            grouped,
-        } = self;
-
-        let open_delimiter = format_open_delimiter(open_token);
-        let close_delimiter = format_close_delimiter(close_token);
-
-        open_delimiter.format_leading_trivia().fmt(f)?;
-
-        let open_token_trailing_trivia = open_delimiter.format_trailing_trivia();
-
-        let close_token_leading_trivia = close_delimiter.format_leading_trivia();
-
-        let delimited = format_with(|f| {
-            open_delimiter.format_token().fmt(f)?;
-
-            let format_content = format_with(|f| f.write_fmt(Arguments::from(content)));
-
-            match mode {
-                DelimitedMode::BlockIndent => block_indent(&format_args![
-                    open_token_trailing_trivia,
-                    format_content, close_token_leading_trivia
-                ])
-                .fmt(f)?,
-                DelimitedMode::SoftBlockIndent(_) => soft_block_indent(&format_args![
-                    open_token_trailing_trivia,
-                    format_content, close_token_leading_trivia
-                ])
-                .fmt(f)?,
-                DelimitedMode::SoftBlockSpaces(_) => {
-                    let mut is_empty = true;
-
-                    let format_content = format_once(|f| {
-                        let mut recording = f.start_recording();
-
-                        write!(
-                            recording,
-                            [
-                                open_token_trailing_trivia,
-                                format_content,
-                                close_token_leading_trivia
-                            ]
-                        )?;
-
-                        is_empty = recording.stop().is_empty();
-
-                        Ok(())
-                    });
-
-                    soft_line_indent_or_space(&format_content).fmt(f)?;
-
-                    if !is_empty {
-                        soft_line_break_or_space().fmt(f)?;
-                    }
-                }
-            };
-
-            close_delimiter.format_token().fmt(f)
-        });
-
-        match mode {
-            _ if !grouped => write!(f, [delimited])?,
-            // Group is useless, the block indent would expand it right anyway
-            DelimitedMode::SoftBlockIndent(group_id) | DelimitedMode::SoftBlockSpaces(group_id) => {
-                match group_id {
-                    None => write!(f, [group(&delimited)])?,
-                    Some(group_id) => {
-                        write!(f, [group(&delimited).with_group_id(Some(*group_id))])?
-                    }
-                }
-            }
-            DelimitedMode::BlockIndent => write!(f, [delimited])?,
-        };
-
-        write!(f, [format_trailing_trivia(close_token)])
-    }
-}
-
-#[derive(Debug, Copy, Clone, Eq, PartialEq)]
-enum DelimitedMode {
-    BlockIndent,
-    SoftBlockIndent(Option<GroupId>),
-    SoftBlockSpaces(Option<GroupId>),
-}
-
-/// Use this function to create an open delimiter, where you can extract the formatting of
-/// trivias and token, separately.
-///
-/// This function assumes that you will use the token to replicate [format_delimited], which means
-/// that it will add possible line breaks
-pub(crate) fn format_open_delimiter(open_token: &JsSyntaxToken) -> OpenDelimiter {
-    OpenDelimiter::new(open_token)
-}
-
-/// Use this function to create an close delimiter, where you can extract the formatting of
-/// trivias and token, separately.
-///
-/// This function assumes that you will use the token to replicate [format_delimited], which means
-/// that it will add possible line breaks
-pub(crate) fn format_close_delimiter(close_token: &JsSyntaxToken) -> CloseDelimiter {
-    CloseDelimiter::new(close_token)
-}
-
-pub(crate) struct OpenDelimiter<'t> {
-    open_token: &'t JsSyntaxToken,
-}
-
-impl<'t> OpenDelimiter<'t> {
-    pub(crate) fn new(open_token: &'t JsSyntaxToken) -> Self {
-        Self { open_token }
-    }
-
-    /// It extracts the formatted leading trivia of the token, without writing it in the buffer
-    pub(crate) fn format_leading_trivia(&self) -> impl Format<JsFormatContext> + 't {
-        format_leading_trivia(self.open_token)
-    }
-
-    /// It extracts the formatted trailing trivia of the token, without writing it in the buffer
-    pub(crate) fn format_trailing_trivia(&self) -> impl Format<JsFormatContext> + 't {
-        format_with(|f| {
-            let mut recording = f.start_recording();
-            write!(recording, [format_trailing_trivia(self.open_token)])?;
-            let recorded = recording.stop();
-
-            if !recorded.is_empty() {
-                soft_line_break().fmt(f)?;
-            }
-
-            Ok(())
-        })
-    }
-
-    /// It extracts the formatted token, without writing it in the buffer
-    pub(crate) fn format_token(&self) -> impl Format<JsFormatContext> + 't {
-        format_with(|f| {
-            f.state_mut().track_token(self.open_token);
-            write!(f, [format_trimmed_token(self.open_token)])
-        })
-    }
-}
-
-pub(crate) struct CloseDelimiter<'t> {
-    close_token: &'t JsSyntaxToken,
-}
-
-impl<'t> CloseDelimiter<'t> {
-    pub(crate) fn new(close_token: &'t JsSyntaxToken) -> Self {
-        Self { close_token }
-    }
-
-    /// It extracts the formatted leading trivia of the token, without writing it in the buffer
-    pub(crate) fn format_trailing_trivia(&self) -> impl Format<JsFormatContext> + 't {
-        format_trailing_trivia(self.close_token)
-    }
-
-    /// It extracts the formatted trailing trivia of the token, without writing it in the buffer
-    pub(crate) fn format_leading_trivia(&self) -> impl Format<JsFormatContext> + 't {
-        format_with(|f| {
-            let mut buffer = PreambleBuffer::new(f, soft_line_break());
-
-            write!(buffer, [format_leading_trivia(self.close_token)])
-        })
-    }
-
-    /// It extracts the formatted token, without writing it in the buffer
-    pub(crate) fn format_token(&self) -> impl Format<JsFormatContext> + 't {
-        format_with(|f| {
-            f.state_mut().track_token(self.close_token);
-            write!(f, [format_trimmed_token(self.close_token)])
-        })
-    }
-}
diff --git a/crates/rome_js_formatter/src/lib.rs b/crates/rome_js_formatter/src/lib.rs
index 2de1638c79e..a4e823daa53 100644
--- a/crates/rome_js_formatter/src/lib.rs
+++ b/crates/rome_js_formatter/src/lib.rs
@@ -252,7 +252,7 @@ pub mod utils;
 mod check_reformat;
 #[rustfmt::skip]
 mod generated;
-pub(crate) mod builders;
+mod builders;
 pub mod comments;
 pub mod context;
 mod parentheses;

From fb3e2a96b0faddc29103ecace85b6cc6359fb2f0 Mon Sep 17 00:00:00 2001
From: Micha Reiser <micha@rome.tools>
Date: Thu, 15 Sep 2022 13:44:28 +0200
Subject: [PATCH 08/15] Rename `cst` back to `token`

Comments Formatter integration
---
 crates/rome_formatter/src/builders.rs       | 201 +---
 crates/rome_formatter/src/format_element.rs |   4 -
 crates/rome_formatter/src/formatter.rs      |  12 +-
 crates/rome_formatter/src/lib.rs            | 132 +--
 crates/rome_formatter/src/prelude.rs        |   6 +-
 crates/rome_formatter/src/printer/mod.rs    |  36 +-
 crates/rome_formatter/src/source_map.rs     |  11 +-
 crates/rome_formatter/src/token.rs          | 966 +++++++-------------
 crates/rome_formatter/src/verbatim.rs       |   2 +-
 9 files changed, 407 insertions(+), 963 deletions(-)

diff --git a/crates/rome_formatter/src/builders.rs b/crates/rome_formatter/src/builders.rs
index 2d262d7a739..a4ccdf0060f 100644
--- a/crates/rome_formatter/src/builders.rs
+++ b/crates/rome_formatter/src/builders.rs
@@ -1,15 +1,11 @@
 use crate::prelude::*;
-use crate::{
-    format_element, write, Argument, Arguments, BufferSnapshot, FormatState, GroupId, TextRange,
-    TextSize,
-};
+use crate::{format_element, write, Argument, Arguments, GroupId, TextRange, TextSize};
 use crate::{Buffer, VecBuffer};
 use rome_rowan::{Language, SyntaxNode, SyntaxToken, SyntaxTokenText, TextLen};
 use std::borrow::Cow;
 use std::cell::Cell;
 use std::marker::PhantomData;
 use std::num::NonZeroU8;
-use std::ops::Deref;
 
 /// A line break that only gets printed if the enclosing `Group` doesn't fit on a single line.
 /// It's omitted if the enclosing `Group` fits on a single line.
@@ -1131,6 +1127,43 @@ impl<Context> std::fmt::Debug for BlockIndent<'_, Context> {
     }
 }
 
+pub fn soft_line_indent_or_spaced<Context>(
+    content: &impl Format<Context>,
+) -> SoftLineIndentOrSpaced<Context> {
+    SoftLineIndentOrSpaced {
+        content: Argument::new(content),
+    }
+}
+
+#[derive(Copy, Clone)]
+pub struct SoftLineIndentOrSpaced<'a, Context> {
+    content: Argument<'a, Context>,
+}
+
+impl<Context> Format<Context> for SoftLineIndentOrSpaced<'_, Context> {
+    fn fmt(&self, f: &mut Formatter<Context>) -> FormatResult<()> {
+        let mut is_empty = true;
+
+        let format_content = format_once(|f| {
+            let mut recording = f.start_recording();
+
+            recording.write_fmt(Arguments::from(&self.content))?;
+
+            is_empty = recording.stop().is_empty();
+
+            Ok(())
+        });
+
+        soft_line_indent_or_space(&format_content).fmt(f)?;
+
+        if !is_empty {
+            soft_line_break_or_space().fmt(f)?;
+        }
+
+        Ok(())
+    }
+}
+
 /// Creates a logical `Group` around the content that should either consistently be printed on a single line
 /// or broken across multiple lines.
 ///
@@ -1240,7 +1273,7 @@ impl<Context> Format<Context> for Group<'_, Context> {
             return f.write_fmt(Arguments::from(&self.content));
         }
 
-        let mut buffer = GroupBuffer::new(f);
+        let mut buffer = VecBuffer::new(f.state_mut());
 
         buffer.write_fmt(Arguments::from(&self.content))?;
 
@@ -1255,9 +1288,7 @@ impl<Context> Format<Context> for Group<'_, Context> {
 
         let group = format_element::Group::new(content).with_id(self.group_id);
 
-        f.write_element(FormatElement::Group(group))?;
-
-        Ok(())
+        f.write_element(FormatElement::Group(group))
     }
 }
 
@@ -1271,154 +1302,6 @@ impl<Context> std::fmt::Debug for Group<'_, Context> {
     }
 }
 
-/// Custom buffer implementation for `GroupElements` that moves the leading comments out of the group
-/// to prevent that a leading line comment expands the token's enclosing group.
-///
-/// # Examples
-///
-/// ```javascript
-/// /* a comment */
-/// [1]
-/// ```
-///
-/// The `/* a comment */` belongs to the `[` group token that is part of a group wrapping the whole
-/// `[1]` expression. It's important that the comment `/* a comment */` gets moved out of the group element
-/// to avoid that the `[1]` group expands because of the line break inserted by the comment.
-struct GroupBuffer<'inner, Context> {
-    inner: &'inner mut dyn Buffer<Context = Context>,
-
-    /// The group inner content
-    content: Vec<FormatElement>,
-}
-
-impl<'inner, Context> GroupBuffer<'inner, Context> {
-    fn new(inner: &'inner mut dyn Buffer<Context = Context>) -> Self {
-        Self {
-            inner,
-            content: Vec::new(),
-        }
-    }
-
-    fn into_vec(self) -> Vec<FormatElement> {
-        self.content
-    }
-
-    fn write_interned(&mut self, interned: Interned) -> FormatResult<()> {
-        debug_assert!(self.content.is_empty());
-
-        match interned.deref() {
-            FormatElement::Comment(_) => {
-                self.inner.write_element(FormatElement::Interned(interned))
-            }
-            FormatElement::List(list) => {
-                let mut content_start = 0;
-
-                for element in list.iter() {
-                    match element {
-                        element @ FormatElement::Comment(_) => {
-                            content_start += 1;
-                            // Cloning comments should be alright as they are rarely nested
-                            // and the case where all elements of an interned data structure are comments
-                            // are rare
-                            self.inner.write_element(element.clone())?;
-                        }
-                        FormatElement::Interned(interned) => {
-                            self.write_interned(interned.clone())?;
-                            content_start += 1;
-
-                            if !self.content.is_empty() {
-                                // Interned struct contained non-comment
-                                break;
-                            }
-                        }
-                        _ => {
-                            // Found the first non-comment / nested interned element
-                            break;
-                        }
-                    }
-                }
-
-                // No leading comments, this group has no comments
-                if content_start == 0 {
-                    self.content.push(FormatElement::Interned(interned));
-                    return Ok(());
-                }
-
-                let content = &list[content_start..];
-
-                // It is necessary to mutate the interned elements, write cloned elements
-                self.write_elements(content.iter().cloned())
-            }
-            FormatElement::Interned(interned) => self.write_interned(interned.clone()),
-            _ => {
-                self.content.push(FormatElement::Interned(interned));
-                Ok(())
-            }
-        }
-    }
-}
-
-impl<Context> Buffer for GroupBuffer<'_, Context> {
-    type Context = Context;
-
-    fn write_element(&mut self, element: FormatElement) -> FormatResult<()> {
-        if self.content.is_empty() {
-            match element {
-                FormatElement::List(list) => {
-                    self.write_elements(list.into_vec())?;
-                }
-                FormatElement::Interned(interned) => match Interned::try_unwrap(interned) {
-                    Ok(owned) => self.write_element(owned)?,
-                    Err(interned) => self.write_interned(interned)?,
-                },
-                comment @ FormatElement::Comment { .. } => {
-                    self.inner.write_element(comment)?;
-                }
-                element => self.content.push(element),
-            }
-        } else {
-            match element {
-                FormatElement::List(list) => {
-                    self.content.extend(list.into_vec());
-                }
-                element => self.content.push(element),
-            }
-        }
-
-        Ok(())
-    }
-
-    fn elements(&self) -> &[FormatElement] {
-        &self.content
-    }
-
-    fn state(&self) -> &FormatState<Self::Context> {
-        self.inner.state()
-    }
-
-    fn state_mut(&mut self) -> &mut FormatState<Self::Context> {
-        self.inner.state_mut()
-    }
-
-    fn snapshot(&self) -> BufferSnapshot {
-        BufferSnapshot::Any(Box::new(GroupElementsBufferSnapshot {
-            inner: self.inner.snapshot(),
-            content_len: self.content.len(),
-        }))
-    }
-
-    fn restore_snapshot(&mut self, snapshot: BufferSnapshot) {
-        let snapshot = snapshot.unwrap_any::<GroupElementsBufferSnapshot>();
-        self.inner.restore_snapshot(snapshot.inner);
-        self.content.truncate(snapshot.content_len);
-    }
-}
-
-struct GroupElementsBufferSnapshot {
-    inner: BufferSnapshot,
-    content_len: usize,
-}
-
 /// IR element that forces the parent group to print in expanded mode.
 ///
 /// Has no effect if used outside of a group or element that introduce implicit groups (fill element).
@@ -2146,9 +2029,9 @@ pub fn get_lines_before<L: Language>(next_node: &SyntaxNode<L>) -> usize {
         leading_trivia
             .pieces()
             .take_while(|piece| {
-                // Stop at the first comment piece, the comment printer
+                // Stop at the first comment or skipped piece, the comment printer
                 // will handle newlines between the comment and the node
-                !piece.is_comments()
+                !(piece.is_comments() || piece.is_skipped())
             })
             .filter(|piece| piece.is_newline())
             .count()
diff --git a/crates/rome_formatter/src/format_element.rs b/crates/rome_formatter/src/format_element.rs
index 79c3c57cc0e..128c6a70271 100644
--- a/crates/rome_formatter/src/format_element.rs
+++ b/crates/rome_formatter/src/format_element.rs
@@ -398,10 +398,6 @@ impl Interned {
     pub(crate) fn new(element: FormatElement) -> Self {
         Self(Rc::new(element))
     }
-
-    pub(crate) fn try_unwrap(this: Interned) -> Result<FormatElement, Interned> {
-        Rc::try_unwrap(this.0).map_err(Interned)
-    }
 }
 
 impl PartialEq for Interned {
diff --git a/crates/rome_formatter/src/formatter.rs b/crates/rome_formatter/src/formatter.rs
index a2b816f0acd..897433cd0cb 100644
--- a/crates/rome_formatter/src/formatter.rs
+++ b/crates/rome_formatter/src/formatter.rs
@@ -2,7 +2,8 @@ use crate::buffer::BufferSnapshot;
 use crate::builders::{FillBuilder, JoinBuilder, JoinNodesBuilder, Line};
 use crate::prelude::*;
 use crate::{
-    Arguments, Buffer, FormatContext, FormatState, FormatStateSnapshot, GroupId, VecBuffer,
+    Arguments, Buffer, Comments, CstFormatContext, FormatContext, FormatState, FormatStateSnapshot,
+    GroupId, VecBuffer,
 };
 
 /// Handles the formatting of a CST and stores the context how the CST should be formatted (user preferences).
@@ -213,6 +214,15 @@ where
     }
 }
 
+impl<Context> Formatter<'_, Context>
+where
+    Context: CstFormatContext,
+{
+    pub fn comments(&self) -> &Comments<Context::Language> {
+        self.context().comments()
+    }
+}
+
 impl<Context> Buffer for Formatter<'_, Context> {
     type Context = Context;
 
diff --git a/crates/rome_formatter/src/lib.rs b/crates/rome_formatter/src/lib.rs
index f8258fdad59..18e06cf9813 100644
--- a/crates/rome_formatter/src/lib.rs
+++ b/crates/rome_formatter/src/lib.rs
@@ -36,12 +36,12 @@ pub mod prelude;
 pub mod printed_tokens;
 pub mod printer;
 mod source_map;
+pub mod token;
 mod verbatim;
 
 use crate::formatter::Formatter;
 use crate::group_id::UniqueGroupIdBuilder;
 use crate::prelude::syntax_token_cow_slice;
-use std::any::TypeId;
 
 #[cfg(debug_assertions)]
 use crate::printed_tokens::PrintedTokens;
@@ -57,10 +57,9 @@ pub use builders::{
 use crate::comments::{CommentStyle, Comments, SourceComment};
 pub use format_element::{normalize_newlines, FormatElement, Text, Verbatim, LINE_TERMINATORS};
 pub use group_id::GroupId;
-use indexmap::IndexSet;
 use rome_rowan::{
-    Language, RawSyntaxKind, SyntaxElement, SyntaxError, SyntaxKind, SyntaxNode, SyntaxResult,
-    SyntaxToken, SyntaxTriviaPieceComments, TextRange, TextSize, TokenAtOffset,
+    Language, SyntaxElement, SyntaxError, SyntaxNode, SyntaxResult, SyntaxToken, SyntaxTriviaPiece,
+    TextRange, TextSize, TokenAtOffset,
 };
 pub use source_map::{TransformSourceMap, TransformSourceMapBuilder};
 use std::error::Error;
@@ -1237,7 +1236,7 @@ pub fn format_sub_tree<L: FormatLanguage>(
     ))
 }
 
-impl<L: Language, Context> Format<Context> for SyntaxTriviaPieceComments<L> {
+impl<L: Language, Context> Format<Context> for SyntaxTriviaPiece<L> {
     fn fmt(&self, f: &mut Formatter<Context>) -> FormatResult<()> {
         let range = self.text_range();
 
@@ -1245,7 +1244,7 @@ impl<L: Language, Context> Format<Context> for SyntaxTriviaPieceComments<L> {
             f,
             [syntax_token_cow_slice(
                 normalize_newlines(self.text().trim(), LINE_TERMINATORS),
-                &self.as_piece().token(),
+                &self.token(),
                 range.start()
             )]
         )
@@ -1262,21 +1261,6 @@ pub struct FormatState<Context> {
 
     group_id_builder: UniqueGroupIdBuilder,
 
-    /// `true` if the last formatted output is an inline comment that may need a space between the next token or comment.
-    last_content_inline_comment: bool,
-
-    /// The kind of the last formatted token
-    last_token_kind: Option<LastTokenKind>,
-
-    /// Tracks comments that have been formatted manually and shouldn't be emitted again
-    /// when formatting the token the comments belong to.
-    ///
-    /// The map stores the absolute position of the manually formatted comments.
-    /// Storing the position is sufficient because comments are guaranteed to not be empty
-    /// (all start with a specific comment sequence) and thus, no two comments can have the same
-    /// absolute position.
-    manually_formatted_comments: IndexSet<TextSize>,
-
     // This is using a RefCell as it only exists in debug mode,
     // the Formatter is still completely immutable in release builds
     #[cfg(debug_assertions)]
@@ -1290,11 +1274,6 @@ where
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         f.debug_struct("FormatState")
             .field("context", &self.context)
-            .field(
-                "has_trailing_inline_comment",
-                &self.last_content_inline_comment,
-            )
-            .field("last_token_kind", &self.last_token_kind)
             .finish()
     }
 }
@@ -1305,9 +1284,7 @@ impl<Context> FormatState<Context> {
         Self {
             context,
             group_id_builder: Default::default(),
-            last_content_inline_comment: false,
-            last_token_kind: None,
-            manually_formatted_comments: IndexSet::default(),
+
             #[cfg(debug_assertions)]
             printed_tokens: Default::default(),
         }
@@ -1317,74 +1294,6 @@ impl<Context> FormatState<Context> {
         self.context
     }
 
-    /// Returns `true` if the last written content is an inline comment with no trailing whitespace.
-    ///
-    /// The formatting of the next content may need to insert a whitespace to separate the
-    /// inline comment from the next content.
-    pub fn is_last_content_inline_comment(&self) -> bool {
-        self.last_content_inline_comment
-    }
-
-    /// Sets whether the last written content is an inline comment that has no trailing whitespace.
-    pub fn set_last_content_inline_comment(&mut self, has_comment: bool) {
-        self.last_content_inline_comment = has_comment;
-    }
-
-    /// Returns the kind of the last formatted token.
-    pub fn last_token_kind(&self) -> Option<LastTokenKind> {
-        self.last_token_kind
-    }
-
-    /// Sets the kind of the last formatted token and sets `last_content_inline_comment` to `false`.
-    pub fn set_last_token_kind<Kind: SyntaxKind + 'static>(&mut self, kind: Kind) {
-        self.set_last_token_kind_raw(Some(LastTokenKind {
-            kind_type: TypeId::of::<Kind>(),
-            kind: kind.to_raw(),
-        }));
-    }
-
-    pub fn set_last_token_kind_raw(&mut self, kind: Option<LastTokenKind>) {
-        self.last_token_kind = kind;
-    }
-
-    /// Mark the passed comment as formatted. This is necessary if a comment from a token is formatted
-    /// to avoid that the comment gets emitted again when formatting that token.
-    ///
-    /// # Examples
-    /// This can be useful when you want to move comments from one token to another.
-    /// For example, when parenthesising an expression:
-    ///
-    /// ```javascript
-    /// console.log("test");
-    /// /* leading */ "string" /* trailing */;
-    /// ```
-    ///
-    /// It is then desired that the leading and trailing comments are outside of the parentheses.
-    ///
-    /// ```javascript
-    /// /* leading */ ("string") /* trailing */;
-    /// ```
-    ///
-    /// This can be accomplished by manually formatting the leading/trailing trivia of the string literal expression
-    /// before/after the close parentheses and then mark the comments as handled.
-    pub fn mark_comment_as_formatted<L: Language>(
-        &mut self,
-        comment: &SyntaxTriviaPieceComments<L>,
-    ) {
-        self.manually_formatted_comments
-            .insert(comment.text_range().start());
-    }
-
-    /// Returns `true` if this comment has already been formatted manually
-    /// and shouldn't be formatted again when formatting the token to which the comment belongs.
-    pub fn is_comment_formatted<L: Language>(
-        &self,
-        comment: &SyntaxTriviaPieceComments<L>,
-    ) -> bool {
-        self.manually_formatted_comments
-            .contains(&comment.text_range().start())
-    }
-
     /// Returns the context specifying how to format the current CST
     pub fn context(&self) -> &Context {
         &self.context
@@ -1432,9 +1341,6 @@ where
 {
     pub fn snapshot(&self) -> FormatStateSnapshot {
         FormatStateSnapshot {
-            last_content_inline_comment: self.last_content_inline_comment,
-            last_token_kind: self.last_token_kind,
-            manual_handled_comments_len: self.manually_formatted_comments.len(),
             #[cfg(debug_assertions)]
             printed_tokens: self.printed_tokens.clone(),
         }
@@ -1442,17 +1348,10 @@ where
 
     pub fn restore_snapshot(&mut self, snapshot: FormatStateSnapshot) {
         let FormatStateSnapshot {
-            last_content_inline_comment,
-            last_token_kind,
-            manual_handled_comments_len,
             #[cfg(debug_assertions)]
             printed_tokens,
         } = snapshot;
 
-        self.last_content_inline_comment = last_content_inline_comment;
-        self.last_token_kind = last_token_kind;
-        self.manually_formatted_comments
-            .truncate(manual_handled_comments_len);
         cfg_if::cfg_if! {
             if #[cfg(debug_assertions)] {
                 self.printed_tokens = printed_tokens;
@@ -1461,26 +1360,7 @@ where
     }
 }
 
-#[derive(Eq, PartialEq, Debug, Copy, Clone)]
-pub struct LastTokenKind {
-    kind_type: TypeId,
-    kind: RawSyntaxKind,
-}
-
-impl LastTokenKind {
-    pub fn as_language<L: Language + 'static>(&self) -> Option<L::Kind> {
-        if self.kind_type == TypeId::of::<L::Kind>() {
-            Some(L::Kind::from_raw(self.kind))
-        } else {
-            None
-        }
-    }
-}
-
 pub struct FormatStateSnapshot {
-    last_content_inline_comment: bool,
-    last_token_kind: Option<LastTokenKind>,
-    manual_handled_comments_len: usize,
     #[cfg(debug_assertions)]
     printed_tokens: PrintedTokens,
 }
diff --git a/crates/rome_formatter/src/prelude.rs b/crates/rome_formatter/src/prelude.rs
index 7e796d60179..80fdc7beafa 100644
--- a/crates/rome_formatter/src/prelude.rs
+++ b/crates/rome_formatter/src/prelude.rs
@@ -4,10 +4,12 @@ pub use crate::format_extensions::{FormatOptional as _, MemoizeFormat, Memoized}
 pub use crate::formatter::Formatter;
 pub use crate::printer::PrinterOptions;
 pub use crate::token::{
-    format_leading_trivia, format_only_if_breaks, format_removed, format_replaced,
-    format_trailing_trivia, format_trimmed_token,
+    format_dangling_comments, format_leading_comments, format_only_if_breaks, format_removed,
+    format_replaced, format_trailing_comments, format_trimmed_token,
 };
 
+pub use crate::verbatim::{format_suppressed_node, format_unknown_node, format_verbatim_node};
+
 pub use crate::{
     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 9bd693a3b02..45a612c102f 100644
--- a/crates/rome_formatter/src/printer/mod.rs
+++ b/crates/rome_formatter/src/printer/mod.rs
@@ -264,10 +264,6 @@ impl<'a> Printer<'a> {
                 self.queue_line_suffixes(HARD_BREAK, args, queue);
             }
 
-            FormatElement::Comment(content) => {
-                queue.extend_with_args(content.iter(), args);
-            }
-
             FormatElement::Verbatim(verbatim) => {
                 if let VerbatimKind::Verbatim { length } = &verbatim.kind {
                     self.state.verbatim_markers.push(TextRange::at(
@@ -355,28 +351,10 @@ impl<'a> Printer<'a> {
             return;
         }
 
-        // If the indentation level has changed since these line suffixes were queued,
-        // insert a line break before to push the comments into the new indent block
-        // SAFETY: Indexing into line_suffixes is guarded by the above call to is_empty
-        let has_line_break = self.state.line_suffixes[0].args.indent.level() < args.indent.level();
-
         // Print this line break element again once all the line suffixes have been flushed
         let call_self = PrintElementCall::new(line_break, args);
 
-        let line_break = if has_line_break {
-            // Duplicate this line break element before the line
-            // suffixes if a line break is required
-            Some(call_self.clone())
-        } else {
-            None
-        };
-
-        queue.extend(
-            line_break
-                .into_iter()
-                .chain(self.state.line_suffixes.drain(..))
-                .chain(once(call_self)),
-        );
+        queue.extend(self.state.line_suffixes.drain(..).chain(once(call_self)));
     }
 
     /// Tries to fit as much content as possible on a single line.
@@ -606,9 +584,9 @@ impl GroupModes {
     }
 
     fn unwrap_print_mode(&self, group_id: GroupId, next_element: &FormatElement) -> PrintMode {
-        self.get_print_mode(group_id).unwrap_or_else(||
+        self.get_print_mode(group_id).unwrap_or_else(|| {
             panic!("Expected group with id {group_id:?} to exist but it wasn't present in the document. Ensure that a group with such a document appears in the document before the element {next_element:?}.")
-        )
+        })
     }
 }
 
@@ -1031,8 +1009,6 @@ fn fits_element_on_line<'a, 'rest>(
             }
         }
 
-        FormatElement::Comment(content) => queue.extend(content.iter(), args),
-
         FormatElement::Verbatim(verbatim) => queue.extend(verbatim.content.iter(), args),
         FormatElement::BestFitting(best_fitting) => {
             let content = match args.mode {
@@ -1438,11 +1414,7 @@ two lines`,
                 text("]")
             ]),
             text(";"),
-            comment(&line_suffix(&format_args![
-                space(),
-                text("// trailing"),
-                space()
-            ]),)
+            &line_suffix(&format_args![space(), text("// trailing"), space()])
         ]);
 
         assert_eq!(printed.as_code(), "[1, 2, 3]; // trailing")
diff --git a/crates/rome_formatter/src/source_map.rs b/crates/rome_formatter/src/source_map.rs
index 2c2c2167b6e..7d1439f51c8 100644
--- a/crates/rome_formatter/src/source_map.rs
+++ b/crates/rome_formatter/src/source_map.rs
@@ -385,9 +385,14 @@ impl TransformSourceMapBuilder {
     /// Creates a new builder for a source map that maps positions back to the passed `root` tree.
     pub fn new() -> Self {
         Self {
-            source_text: String::new(),
-            deleted_ranges: Vec::new(),
-            mapped_node_ranges: FxHashMap::default(),
+            ..Default::default()
+        }
+    }
+
+    pub fn with_source(source: String) -> Self {
+        Self {
+            source_text: source,
+            ..Default::default()
         }
     }
 
diff --git a/crates/rome_formatter/src/token.rs b/crates/rome_formatter/src/token.rs
index 04d8fdfb3d9..aff140e6ced 100644
--- a/crates/rome_formatter/src/token.rs
+++ b/crates/rome_formatter/src/token.rs
@@ -1,278 +1,266 @@
-use crate::comments::{CommentKind, CommentStyle, SourceComment};
 use crate::prelude::*;
 use crate::{
-    format_args, write, Argument, Arguments, CstFormatContext, FormatRefWithRule, GroupId,
-    LastTokenKind,
+    write, Argument, Arguments, CommentKind, CommentStyle, CstFormatContext, FormatRefWithRule,
+    GroupId, SourceComment, TextRange, VecBuffer,
 };
-use rome_rowan::{Language, SyntaxToken, SyntaxTriviaPiece};
+use rome_rowan::{Language, SyntaxNode, SyntaxToken};
 
-///! Provides builders for working with tokens and the tokens trivia
+///! Provides builders for formatting a CST.
 
-/// Formats a token without its leading or trailing trivia
-///
-/// ## Warning
-/// It's your responsibility to format leading or trailing comments and skipped trivia.
-pub const fn format_trimmed_token<L: Language>(token: &SyntaxToken<L>) -> FormatTrimmedToken<L> {
-    FormatTrimmedToken { token }
+/// Formats the leading comments of `node`
+pub const fn format_leading_comments<L: Language>(
+    node: &SyntaxNode<L>,
+) -> FormatLeadingComments<L> {
+    FormatLeadingComments::Node(node)
 }
 
-#[derive(Debug, Eq, PartialEq, Copy, Clone)]
-pub struct FormatTrimmedToken<'a, L: Language> {
-    token: &'a SyntaxToken<L>,
+/// Formats the leading comments of a node.
+#[derive(Debug, Copy, Clone)]
+pub enum FormatLeadingComments<'a, L: Language> {
+    Node(&'a SyntaxNode<L>),
+    Comments(&'a [SourceComment<L>]),
 }
 
-impl<L: Language + 'static, C> Format<C> for FormatTrimmedToken<'_, L>
+impl<Context> Format<Context> for FormatLeadingComments<'_, Context::Language>
 where
-    C: CstFormatContext<Language = L>,
+    Context: CstFormatContext,
 {
-    fn fmt(&self, f: &mut Formatter<C>) -> FormatResult<()> {
-        write_space_between_comment_and_token(self.token.kind(), f)?;
-
-        f.state_mut().set_last_token_kind(self.token.kind());
+    fn fmt(&self, f: &mut Formatter<Context>) -> FormatResult<()> {
+        let comments = f.context().comments().clone();
+
+        let leading_comments = match self {
+            FormatLeadingComments::Node(node) => comments.leading_comments(node),
+            FormatLeadingComments::Comments(comments) => comments,
+        };
+
+        for comment in leading_comments {
+            let format_comment = FormatRefWithRule::new(comment, Context::CommentRule::default());
+            write!(f, [format_comment])?;
+
+            match comment.kind() {
+                CommentKind::Block | CommentKind::InlineBlock => {
+                    match comment.lines_after() {
+                        0 => write!(f, [space()])?,
+                        1 => {
+                            if comment.lines_before() == 0 {
+                                write!(f, [soft_line_break_or_space()])?;
+                            } else {
+                                write!(f, [hard_line_break()])?;
+                            }
+                        }
+                        _ => write!(f, [empty_line()])?,
+                    };
+                }
+                CommentKind::Line => match comment.lines_after() {
+                    0 | 1 => write!(f, [hard_line_break()])?,
+                    _ => write!(f, [empty_line()])?,
+                },
+            }
+        }
 
-        let trimmed_range = self.token.text_trimmed_range();
-        syntax_token_text_slice(self.token, trimmed_range).fmt(f)
+        Ok(())
     }
 }
 
-/// Formats a token that has been inserted by the formatter and isn't present in the source text.
-/// Takes care of correctly handling spacing to the previous token's trailing trivia.
-pub struct FormatInserted<L>
-where
-    L: Language,
-{
-    kind: L::Kind,
-    text: &'static str,
+/// Formats the trailing comments of `node`.
+pub const fn format_trailing_comments<L: Language>(
+    node: &SyntaxNode<L>,
+) -> FormatTrailingComments<L> {
+    FormatTrailingComments::Node(node)
 }
 
-impl<L> FormatInserted<L>
-where
-    L: Language,
-{
-    pub fn new(kind: L::Kind, text: &'static str) -> Self {
-        Self { kind, text }
-    }
+/// Formats the trailing comments of `node`
+#[derive(Debug, Clone, Copy)]
+pub enum FormatTrailingComments<'a, L: Language> {
+    Node(&'a SyntaxNode<L>),
+    Comments(&'a [SourceComment<L>]),
 }
 
-impl<L, C> Format<C> for FormatInserted<L>
+impl<Context> Format<Context> for FormatTrailingComments<'_, Context::Language>
 where
-    L: Language + 'static,
-    C: CstFormatContext<Language = L>,
+    Context: CstFormatContext,
 {
-    fn fmt(&self, f: &mut Formatter<C>) -> FormatResult<()> {
-        write_space_between_comment_and_token(self.kind, f)?;
+    fn fmt(&self, f: &mut Formatter<Context>) -> FormatResult<()> {
+        let comments = f.context().comments().clone();
+        let trailing_comments = match self {
+            FormatTrailingComments::Node(node) => comments.trailing_comments(node),
+            FormatTrailingComments::Comments(comments) => comments,
+        };
+
+        let mut total_lines_before = 0;
+
+        for comment in trailing_comments {
+            total_lines_before += comment.lines_before();
+
+            let format_comment = FormatRefWithRule::new(comment, Context::CommentRule::default());
+
+            // This allows comments at the end of nested structures:
+            // {
+            //   x: 1,
+            //   y: 2
+            //   // A comment
+            // }
+            // Those kinds of comments are almost always leading comments, but
+            // here it doesn't go "outside" the block and turns it into a
+            // trailing comment for `2`. We can simulate the above by checking
+            // if this a comment on its own line; normal trailing comments are
+            // always at the end of another expression.
+            if total_lines_before > 0 {
+                write!(
+                    f,
+                    [
+                        line_suffix(&format_with(|f| {
+                            match comment.lines_before() {
+                                0 | 1 => write!(f, [hard_line_break()])?,
+                                _ => write!(f, [empty_line()])?,
+                            };
+
+                            write!(f, [format_comment])
+                        })),
+                        expand_parent()
+                    ]
+                )?;
+            } else {
+                let content = format_with(|f| write!(f, [space(), format_comment]));
+                if comment.kind().is_line() {
+                    write!(f, [line_suffix(&content), expand_parent()])?;
+                } else {
+                    write!(f, [content])?;
+                }
+            }
+        }
 
-        f.state_mut().set_last_token_kind(self.kind);
-        text(self.text).fmt(f)
+        Ok(())
     }
 }
 
-fn write_space_between_comment_and_token<L: Language, Context>(
-    token_kind: <L as Language>::Kind,
-    f: &mut Formatter<Context>,
-) -> FormatResult<()>
-where
-    Context: CstFormatContext<Language = L>,
-{
-    let is_last_content_inline_content = f.state().is_last_content_inline_comment();
-
-    // Insert a space if the previous token has any trailing comments and this is not a group
-    // end token
-    #[allow(deprecated)]
-    if is_last_content_inline_content && !f.context().comment_style().is_group_end_token(token_kind)
-    {
-        space().fmt(f)?;
+pub const fn format_dangling_comments<L: Language>(
+    node: &SyntaxNode<L>,
+) -> FormatDanglingComments<L> {
+    FormatDanglingComments::Node {
+        node,
+        indent: DanglingIndentMode::None,
     }
+}
 
-    f.state_mut().set_last_content_inline_comment(false);
+/// Formats the dangling trivia of `token`.
+pub enum FormatDanglingComments<'a, L: Language> {
+    Node {
+        node: &'a SyntaxNode<L>,
+        indent: DanglingIndentMode,
+    },
+    Comments {
+        comments: &'a [SourceComment<L>],
+        indent: DanglingIndentMode,
+    },
+}
 
-    Ok(())
+#[derive(Copy, Clone, Debug)]
+pub enum DanglingIndentMode {
+    Block,
+    Soft,
+    None,
 }
 
-/// Inserts a open parentheses before the specified token and ensures
-/// that any leading trivia of the token is formatted **before** the inserted parentheses.
-///
-/// # Example
-///
-/// ```javascript
-/// /* leading */ "string";
-/// ```
-///
-/// Becomes
-///
-/// ```javascript
-/// /* leading */ ("string";
-/// ```
-///
-/// when inserting the "(" before the "string" token.
-#[derive(Clone, Debug)]
-pub struct FormatInsertedOpenParen<'a, L>
-where
-    L: Language,
-{
-    /// The token before which the open paren must be inserted
-    before_token: Option<&'a SyntaxToken<L>>,
+impl<L: Language> FormatDanglingComments<'_, L> {
+    pub fn with_block_indent(self) -> Self {
+        self.with_indent_mode(DanglingIndentMode::Block)
+    }
 
-    /// The token text of the open paren
-    text: &'static str,
+    pub fn with_soft_block_indent(self) -> Self {
+        self.with_indent_mode(DanglingIndentMode::Soft)
+    }
 
-    /// The kind of the open paren
-    kind: L::Kind,
-}
+    fn with_indent_mode(mut self, mode: DanglingIndentMode) -> Self {
+        match &mut self {
+            FormatDanglingComments::Node { indent, .. } => *indent = mode,
+            FormatDanglingComments::Comments { indent, .. } => *indent = mode,
+        }
+        self
+    }
 
-impl<'a, L> FormatInsertedOpenParen<'a, L>
-where
-    L: Language,
-{
-    pub fn new(
-        before_token: Option<&'a SyntaxToken<L>>,
-        kind: L::Kind,
-        text: &'static str,
-    ) -> Self {
-        Self {
-            before_token,
-            kind,
-            text,
+    const fn indent(&self) -> DanglingIndentMode {
+        match self {
+            FormatDanglingComments::Node { indent, .. } => *indent,
+            FormatDanglingComments::Comments { indent, .. } => *indent,
         }
     }
 }
 
-impl<Context, L> Format<Context> for FormatInsertedOpenParen<'_, L>
+impl<Context> Format<Context> for FormatDanglingComments<'_, Context::Language>
 where
-    L: Language + 'static,
-    Context: CstFormatContext<Language = L>,
+    Context: CstFormatContext,
 {
     fn fmt(&self, f: &mut Formatter<Context>) -> FormatResult<()> {
-        let mut comments = Vec::new();
-
-        if let Some(before_token) = &self.before_token {
-            // Format the leading trivia of the next token as the leading trivia of the open paren.
-            let leading_pieces = before_token.leading_trivia().pieces();
-
-            let mut lines_before = 0;
-
-            for piece in leading_pieces {
-                if let Some(comment) = piece.as_comments() {
-                    comments.push(SourceComment::leading(comment, lines_before));
-                    lines_before = 0;
-                } else if piece.is_newline() {
-                    lines_before += 1;
-                } else if piece.is_skipped() {
-                    // Keep the skipped trivia inside of the parens. Handled by the
-                    // formatting of the `before_token`.
-                    break;
-                }
-            }
+        let comments = f.context().comments().clone();
+        let dangling_comments = match self {
+            FormatDanglingComments::Node { node, .. } => comments.dangling_comments(node),
+            FormatDanglingComments::Comments { comments, .. } => *comments,
+        };
 
-            write!(
-                f,
-                [FormatLeadingComments {
-                    comments: &comments,
-                    trim_mode: TriviaPrintMode::Full,
-                    lines_before_token: lines_before,
-                }]
-            )?;
+        if dangling_comments.is_empty() {
+            return Ok(());
         }
 
-        write!(
-            f,
-            [FormatInserted {
-                kind: self.kind,
-                text: self.text,
-            }]
-        )?;
-
-        // Prevent that the comments get formatted again when formatting the
-        // `before_token`
-        for comment in comments {
-            f.state_mut().mark_comment_as_formatted(comment.piece());
-        }
+        let format_dangling_comments = format_with(|f| {
+            // Write all comments up to the first skipped token trivia or the token
+            let mut join = f.join_with(hard_line_break());
 
-        Ok(())
-    }
-}
+            for comment in dangling_comments {
+                let format_comment =
+                    FormatRefWithRule::new(comment, Context::CommentRule::default());
+                join.entry(&format_comment);
+            }
 
-/// Inserts a closing parentheses before another token and moves that tokens
-/// trailing trivia after the closing parentheses.
-///
-/// # Example
-///
-/// ```javascript
-/// "string" /* trailing */;
-/// ```
-///
-/// Becomes
-///
-/// ```javascript
-/// "string") /* trailing */
-/// ```
-#[derive(Clone, Debug)]
-pub struct FormatInsertedCloseParen<L>
-where
-    L: Language,
-{
-    /// The token after which the close paren must be inserted
-    comments: Vec<SourceComment<L>>,
+            join.finish()?;
 
-    /// The token text of the close paren
-    text: &'static str,
+            if matches!(self.indent(), DanglingIndentMode::Soft)
+                && dangling_comments
+                    .last()
+                    .map_or(false, |comment| comment.kind().is_line())
+            {
+                write!(f, [hard_line_break()])?;
+            }
 
-    /// The kind of the close paren
-    kind: L::Kind,
-}
+            Ok(())
+        });
 
-impl<L> FormatInsertedCloseParen<L>
-where
-    L: Language,
-{
-    pub fn after_token<Context>(
-        after_token: Option<&SyntaxToken<L>>,
-        kind: L::Kind,
-        text: &'static str,
-        f: &mut Formatter<Context>,
-    ) -> Self {
-        let mut comments = Vec::new();
-
-        if let Some(after_token) = after_token {
-            // "Steal" the trailing comments and mark them as handled.
-            // Must be done eagerly before formatting because the `after_token`
-            // gets formatted **before** formatting the inserted paren.
-            for piece in after_token.trailing_trivia().pieces() {
-                if let Some(comment) = piece.as_comments() {
-                    f.state_mut().mark_comment_as_formatted(&comment);
-                    comments.push(SourceComment::trailing(comment));
-                }
+        match self.indent() {
+            DanglingIndentMode::Block => {
+                write!(f, [block_indent(&format_dangling_comments)])
+            }
+            DanglingIndentMode::Soft => {
+                write!(f, [group(&soft_block_indent(&format_dangling_comments))])
+            }
+            DanglingIndentMode::None => {
+                write!(f, [format_dangling_comments])
             }
-        }
-
-        Self {
-            comments,
-            kind,
-            text,
         }
     }
 }
 
-impl<Context, L> Format<Context> for FormatInsertedCloseParen<L>
+/// Formats a token without its leading or trailing trivia
+///
+/// ## Warning
+/// It's your responsibility to format leading or trailing comments and skipped trivia.
+pub const fn format_trimmed_token<L: Language>(token: &SyntaxToken<L>) -> FormatTrimmedToken<L> {
+    FormatTrimmedToken { token }
+}
+
+#[derive(Debug, Eq, PartialEq, Copy, Clone)]
+pub struct FormatTrimmedToken<'a, L: Language> {
+    token: &'a SyntaxToken<L>,
+}
+
+impl<L: Language + 'static, C> Format<C> for FormatTrimmedToken<'_, L>
 where
-    L: Language + 'static,
-    Context: CstFormatContext<Language = L>,
+    C: CstFormatContext<Language = L>,
 {
-    fn fmt(&self, f: &mut Formatter<Context>) -> FormatResult<()> {
-        write!(
-            f,
-            [
-                FormatInserted {
-                    kind: self.kind,
-                    text: self.text,
-                },
-                FormatTrailingTrivia::new(self.comments.iter().cloned(), self.kind,)
-                    .skip_formatted_check()
-            ]
-        )
+    fn fmt(&self, f: &mut Formatter<C>) -> FormatResult<()> {
+        let trimmed_range = self.token.text_trimmed_range();
+        syntax_token_text_slice(self.token, trimmed_range).fmt(f)
     }
 }
-
 /// Formats the leading and trailing trivia of a removed token.
 ///
 /// Formats all leading and trailing comments up to the first line break or skipped token trivia as a trailing
@@ -301,56 +289,8 @@ where
     fn fmt(&self, f: &mut Formatter<C>) -> FormatResult<()> {
         f.state_mut().track_token(self.token);
 
-        let last = f.state().last_token_kind();
-
-        write_removed_token_trivia(self.token, last, f)
-    }
-}
-
-/// Writes the trivia of a removed token
-fn write_removed_token_trivia<C, L>(
-    token: &SyntaxToken<L>,
-    last_token: Option<LastTokenKind>,
-    f: &mut Formatter<C>,
-) -> FormatResult<()>
-where
-    L: Language + 'static,
-    C: CstFormatContext<Language = L>,
-{
-    let mut pieces = token
-        .leading_trivia()
-        .pieces()
-        .chain(token.trailing_trivia().pieces())
-        .peekable();
-
-    let last_token = last_token.and_then(|token| token.as_language::<L>());
-
-    // If this isn't the first token than format all comments that are before the first skipped token
-    // trivia or line break as the trailing trivia of the previous token (which these comments will
-    // become if the document gets formatted a second time).
-    if let Some(last_token) = last_token.as_ref() {
-        let mut trailing_comments = vec![];
-
-        while let Some(piece) = pieces.peek() {
-            if let Some(comment) = piece.as_comments() {
-                if !f.state().is_comment_formatted(&comment) {
-                    trailing_comments.push(SourceComment::trailing(comment));
-                }
-            } else if piece.is_newline() || piece.is_skipped() {
-                break;
-            }
-
-            pieces.next();
-        }
-
-        FormatTrailingTrivia::new(trailing_comments.into_iter(), *last_token).fmt(f)?;
+        write!(f, [format_skipped_token_trivia(self.token)])
     }
-
-    write_leading_trivia(pieces, token, TriviaPrintMode::Full, f, || {
-        token.prev_token()
-    })?;
-
-    Ok(())
 }
 
 /// Print out a `token` from the original source with a different `content`.
@@ -389,14 +329,9 @@ where
     fn fmt(&self, f: &mut Formatter<C>) -> FormatResult<()> {
         f.state_mut().track_token(self.token);
 
-        format_leading_trivia(self.token).fmt(f)?;
-
-        write_space_between_comment_and_token(self.token.kind(), f)?;
+        write!(f, [format_skipped_token_trivia(self.token)])?;
 
-        f.state_mut().set_last_token_kind(self.token.kind());
-
-        f.write_fmt(Arguments::from(&self.content))?;
-        format_trailing_trivia(self.token).fmt(f)
+        f.write_fmt(Arguments::from(&self.content))
     }
 }
 
@@ -443,408 +378,169 @@ where
     C: CstFormatContext<Language = L>,
 {
     fn fmt(&self, f: &mut Formatter<C>) -> FormatResult<()> {
-        // Store the last token and last trailing comment before formatting the content which will override the state.
-        // Is it safe to set `last_trailing_comment` only in the format removed because format removed may set it to true
-        // but it's false for the "break" case. Ignorable, because it's after a new line break in that case?
-        let last_token = f.state().last_token_kind();
-        let is_last_content_inline_comment = f.state().is_last_content_inline_comment();
-
         write!(
             f,
             [
                 if_group_breaks(&Arguments::from(&self.content)).with_group_id(self.group_id),
                 // Print the trivia otherwise
-                if_group_fits_on_line(&format_with(|f| {
-                    // Restore state to how it was before formatting the "breaks" variant
-                    f.state_mut().set_last_token_kind_raw(last_token);
-                    f.state_mut()
-                        .set_last_content_inline_comment(is_last_content_inline_comment);
-
-                    write_removed_token_trivia(self.token, last_token, f)
-                }))
-                .with_group_id(self.group_id),
+                if_group_fits_on_line(&format_skipped_token_trivia(self.token))
+                    .with_group_id(self.group_id),
             ]
         )
     }
 }
 
-/// Determines if the whitespace separating comment trivia
-/// from their associated tokens should be printed or trimmed
-#[derive(Copy, Clone, Debug, Eq, PartialEq, Default)]
-pub enum TriviaPrintMode {
-    #[default]
-    Full,
-    Trim,
-}
-
-/// Formats the leading trivia (comments, skipped token trivia) of a token
-pub fn format_leading_trivia<L: Language>(token: &SyntaxToken<L>) -> FormatLeadingTrivia<L> {
-    FormatLeadingTrivia {
-        trim_mode: TriviaPrintMode::Full,
-        token,
-    }
+pub const fn format_skipped_token_trivia<L: Language>(
+    token: &SyntaxToken<L>,
+) -> FormatSkippedTokenTrivia<L> {
+    FormatSkippedTokenTrivia { token }
 }
 
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub struct FormatLeadingTrivia<'a, L>
-where
-    L: Language,
-{
-    trim_mode: TriviaPrintMode,
+pub struct FormatSkippedTokenTrivia<'a, L: Language> {
     token: &'a SyntaxToken<L>,
 }
 
-impl<'a, L> FormatLeadingTrivia<'a, L>
-where
-    L: Language,
-{
-    pub fn with_trim_mode(mut self, mode: TriviaPrintMode) -> Self {
-        self.trim_mode = mode;
-        self
-    }
-}
-
-impl<L, C> Format<C> for FormatLeadingTrivia<'_, L>
-where
-    L: Language,
-    C: CstFormatContext<Language = L>,
-{
-    fn fmt(&self, f: &mut Formatter<C>) -> FormatResult<()> {
-        write_leading_trivia(
-            self.token.leading_trivia().pieces(),
-            self.token,
-            self.trim_mode,
-            f,
-            || self.token.prev_token(),
-        )
-    }
-}
-
-fn write_leading_trivia<I, L, C, F>(
-    pieces: I,
-    token: &SyntaxToken<L>,
-    trim_mode: TriviaPrintMode,
-    f: &mut Formatter<C>,
-    previous_token: F,
-) -> FormatResult<()>
-where
-    I: IntoIterator<Item = SyntaxTriviaPiece<L>>,
-    L: Language,
-    C: CstFormatContext<Language = L>,
-    F: FnOnce() -> Option<SyntaxToken<L>>,
-{
-    let mut lines_before = 0;
-    let mut comments = Vec::new();
-    let mut pieces = pieces.into_iter();
-
-    while let Some(piece) = pieces.next() {
-        if let Some(comment) = piece.as_comments() {
-            if !f.state().is_comment_formatted(&comment) {
-                comments.push(SourceComment::leading(comment, lines_before));
-            }
-
-            lines_before = 0;
-        } else if piece.is_newline() {
-            lines_before += 1;
-        } else if piece.is_skipped() {
-            // Special handling for tokens that have skipped trivia:
-            //
-            // ```
-            // class {
-            //   // comment
-            //   @test(/* inner */) // trailing
-            //   /* token leading */
-            //   method() {}
-            // }
-            // ```
-            // If `@test(/*inner)` are skipped trivia that are part of the `method` tokens leading trivia, then the
-            // following code splits the trivia into for parts:
-            // 1. The first skipped trivia's leading comments: Comments that come before the first skipped trivia `@`: The `// comment`
-            // 2. Skipped trivia: All trivia pieces between the first and last skipped trivia: `@test(/* inner *)`. Gets formatted as verbatim
-            // 3. Trailing comments of the last skipped token: All comments that are on the same line as the last skipped trivia. The `// trailing` comment
-            // 4. The token's leading trivia: All comments that are not on the same line as the last skipped token trivia: `/* token leading */`
-
-            // Format the 1. part, the skipped trivia's leading comments
-            FormatLeadingComments {
-                comments: &comments,
-                trim_mode: TriviaPrintMode::Full,
-                lines_before_token: lines_before,
-            }
-            .fmt(f)?;
-
-            let has_preceding_whitespace = previous_token()
-                .and_then(|token| token.trailing_trivia().pieces().last())
-                .map_or(false, |piece| piece.is_newline() || piece.is_whitespace());
-
-            // Maintain a leading whitespace in front of the skipped token trivia
-            // if the previous token has a trailing whitespace (and there's no comment between the two tokens).
-            if comments.is_empty() && has_preceding_whitespace {
-                write!(f, [space()])?;
-            }
-
-            comments.clear();
-            lines_before = 0;
-
-            // Count the whitespace between the last skipped token trivia and the token
-            let mut spaces = 0;
-            // The range that covers from the first to the last skipped token trivia
-            let mut skipped_trivia_range = piece.text_range();
-
-            for piece in pieces {
-                if piece.is_whitespace() {
-                    spaces += 1;
-                    continue;
-                }
-
-                spaces = 0;
-
-                // If this is another skipped trivia, then extend the skipped range and
-                // clear all accumulated comments because they are formatted as verbatim as part of the
-                // skipped token trivia
-                if piece.is_skipped() {
-                    skipped_trivia_range = skipped_trivia_range.cover(piece.text_range());
-                    comments.clear();
-                    lines_before = 0;
-                } else if let Some(comment) = piece.as_comments() {
-                    comments.push(SourceComment::leading(comment, lines_before));
-                    lines_before = 0;
-                } else if piece.is_newline() {
-                    lines_before += 1;
+impl<L: Language> FormatSkippedTokenTrivia<'_, L> {
+    #[cold]
+    fn fmt_skipped<Context>(&self, f: &mut Formatter<Context>) -> FormatResult<()>
+    where
+        Context: CstFormatContext<Language = L>,
+    {
+        // Lines/spaces before the next token/comment
+        let (mut lines, mut spaces) = match self.token.prev_token() {
+            Some(token) => {
+                let mut lines = 0u32;
+                let mut spaces = 0u32;
+                for piece in token.trailing_trivia().pieces().rev() {
+                    if piece.is_whitespace() {
+                        spaces += 1;
+                    } else if piece.is_newline() {
+                        spaces = 0;
+                        lines += 1;
+                    } else {
+                        break;
+                    }
                 }
-            }
-
-            // Format the skipped token trivia range
-            syntax_token_text_slice(token, skipped_trivia_range).fmt(f)?;
-
-            // Find the start position of the next token's leading comments.
-            // The start is the first comment that is preceded by a line break.
-            let first_token_leading_comment = comments
-                .iter()
-                .position(|comment| comment.lines_before() > 0)
-                .unwrap_or(comments.len());
-
-            // Everything before the start position are trailing comments of the last skipped token
-            let token_leading_comments = comments.split_off(first_token_leading_comment);
-            let skipped_trailing_comments = comments;
-
-            // Format the trailing comments of the last skipped token trivia
-            FormatTrailingTrivia::skipped(skipped_trailing_comments.into_iter()).fmt(f)?;
 
-            // Ensure that there's some whitespace between the last skipped token trivia and the
-            // next token except if there was no whitespace present in the source.
-            if lines_before > 0 {
-                write!(f, [hard_line_break()])?;
-            } else if spaces > 0 {
-                write!(f, [space()])?;
-            };
-
-            // Write  leading comments of the next token
-            FormatLeadingComments {
-                comments: &token_leading_comments,
-                lines_before_token: lines_before,
-                trim_mode,
+                (lines, spaces)
             }
-            .fmt(f)?;
-
-            return Ok(());
-        }
-    }
-
-    FormatLeadingComments {
-        comments: &comments,
-        trim_mode,
-        lines_before_token: lines_before,
-    }
-    .fmt(f)
-}
-
-struct FormatLeadingComments<'a, L>
-where
-    L: Language,
-{
-    comments: &'a [SourceComment<L>],
-    trim_mode: TriviaPrintMode,
-    lines_before_token: u32,
-}
-
-impl<L, C> Format<C> for FormatLeadingComments<'_, L>
-where
-    L: Language,
-    C: CstFormatContext<Language = L>,
-{
-    fn fmt(&self, f: &mut Formatter<C>) -> FormatResult<()> {
-        let mut first = true;
-        let mut last_inline_comment = f.state().is_last_content_inline_comment();
-
-        for (index, comment) in self.comments.iter().enumerate() {
-            if f.state().is_comment_formatted(comment.piece()) {
+            None => (0, 0),
+        };
+
+        // The comments between the last skipped token trivia and the token
+        let mut dangling_comments = Vec::new();
+        let mut skipped_range: Option<TextRange> = None;
+
+        // Iterate over the remaining pieces to find the full range from the first to the last skipped token trivia.
+        // Extract the comments between the last skipped token trivia and the token.
+        for piece in self.token.leading_trivia().pieces() {
+            if piece.is_whitespace() {
+                spaces += 1;
                 continue;
             }
 
-            let lines_after = self
-                .comments
-                .get(index + 1)
-                .map(|comment| comment.lines_before())
-                .unwrap_or_else(|| match self.trim_mode {
-                    TriviaPrintMode::Full => self.lines_before_token,
-                    TriviaPrintMode::Trim => 0,
-                });
-
-            #[allow(deprecated)]
-            let comment_kind = f
-                .context()
-                .comment_style()
-                .get_comment_kind(comment.piece());
-
-            last_inline_comment = comment_kind.is_inline() && lines_after == 0;
-
-            let format_content = format_with(|f| {
-                if comment.lines_before() > 0 && first {
-                    write!(f, [hard_line_break()])?;
-                } else if !first {
-                    write!(f, [space()])?;
+            if piece.is_newline() {
+                lines += 1;
+                spaces = 0;
+            } else if let Some(comment) = piece.as_comments() {
+                let source_comment = SourceComment {
+                    kind: Context::Style::get_comment_kind(&comment),
+                    lines_before: lines,
+                    lines_after: 0,
+                    piece: comment,
                 };
 
-                let format_comment =
-                    FormatRefWithRule::new(comment, C::LeadingCommentRule::default());
+                dangling_comments.push(source_comment);
 
-                write!(f, [format_comment])?;
-
-                match comment_kind {
-                    CommentKind::Line => match lines_after {
-                        0 | 1 => write!(f, [hard_line_break()])?,
-                        _ => write!(f, [empty_line()])?,
-                    },
-                    CommentKind::InlineBlock | CommentKind::Block => {
-                        match lines_after {
-                            0 => {
-                                // space between last comment and token handled at the end.
-                                // space between comments is inserted before each comment
-                            }
-                            1 => write!(f, [hard_line_break()])?,
-                            _ => write!(f, [empty_line()])?,
+                lines = 0;
+                spaces = 0;
+            } else if piece.is_skipped() {
+                skipped_range = Some(match skipped_range {
+                    Some(range) => range.cover(piece.text_range()),
+                    None => {
+                        if dangling_comments.is_empty() {
+                            match lines {
+                                0 if spaces == 0 => {
+                                    // Token had no space to previous token nor any preceding comment. Keep it that way
+                                }
+                                0 => write!(f, [space()])?,
+                                _ => write!(f, [hard_line_break()])?,
+                            };
+                        } else {
+                            match lines {
+                                0 => write!(f, [space()])?,
+                                1 => write!(f, [hard_line_break()])?,
+                                _ => write!(f, [empty_line()])?,
+                            };
                         }
-                    }
-                }
 
-                Ok(())
-            });
+                        piece.text_range()
+                    }
+                });
 
-            write!(f, [crate::comment(&format_content)])?;
-            first = false;
+                lines = 0;
+                spaces = 0;
+                dangling_comments.clear();
+            }
         }
 
-        f.state_mut()
-            .set_last_content_inline_comment(last_inline_comment);
+        let skipped_range =
+            skipped_range.unwrap_or_else(|| TextRange::empty(self.token.text_range().start()));
 
-        Ok(())
-    }
-}
+        let verbatim = {
+            let mut buffer = VecBuffer::new(f.state_mut());
+            write!(buffer, [syntax_token_text_slice(self.token, skipped_range)])?;
 
-/// Formats the trailing trivia (comments) of a token
-pub fn format_trailing_trivia<L: Language>(
-    token: &SyntaxToken<L>,
-) -> FormatTrailingTrivia<impl Iterator<Item = SourceComment<L>> + Clone, L> {
-    let comments = token
-        .trailing_trivia()
-        .pieces()
-        .filter_map(|piece| piece.as_comments().map(SourceComment::trailing));
+            FormatElement::Verbatim(Verbatim::new_verbatim(
+                buffer.into_vec().into_boxed_slice(),
+                skipped_range.len(),
+            ))
+        };
 
-    FormatTrailingTrivia::new(comments, token.kind())
-}
+        f.write_element(verbatim)?;
 
-#[derive(Debug, Copy, Clone)]
-pub struct FormatTrailingTrivia<I, L: Language>
-where
-    I: Iterator<Item = SourceComment<L>> + Clone,
-{
-    /// The comments to format
-    comments: I,
-
-    /// The kind of the token of which the comments are the trailing trivia.
-    /// `Some(kind)` for a regular token. `None` for a skipped token trivia OR
-    token_kind: Option<<L as Language>::Kind>,
-
-    skip_formatted_check: bool,
-}
+        // Write whitespace separator between skipped/last comment and token
+        if dangling_comments.is_empty() {
+            match lines {
+                0 if spaces == 0 => {
+                    // Don't write a space if there was non in the source document
+                    Ok(())
+                }
+                0 => write!(f, [space()]),
+                _ => write!(f, [hard_line_break()]),
+            }
+        } else {
+            match dangling_comments.first().unwrap().lines_before {
+                0 => write!(f, [space()])?,
+                1 => write!(f, [hard_line_break()])?,
+                _ => write!(f, [empty_line()])?,
+            }
 
-impl<I, L: Language> FormatTrailingTrivia<I, L>
-where
-    I: Iterator<Item = SourceComment<L>> + Clone,
-{
-    pub fn new(comments: I, token_kind: L::Kind) -> Self {
-        Self {
-            comments,
-            token_kind: Some(token_kind),
-            skip_formatted_check: false,
-        }
-    }
+            write!(
+                f,
+                [FormatDanglingComments::Comments {
+                    comments: &dangling_comments,
+                    indent: DanglingIndentMode::None
+                }]
+            )?;
 
-    pub fn skipped(comments: I) -> Self {
-        Self {
-            comments,
-            token_kind: None,
-            skip_formatted_check: false,
+            match lines {
+                0 => write!(f, [space()]),
+                _ => write!(f, [hard_line_break()]),
+            }
         }
     }
-
-    pub fn skip_formatted_check(mut self) -> Self {
-        self.skip_formatted_check = true;
-        self
-    }
 }
 
-impl<I, L: Language, C> Format<C> for FormatTrailingTrivia<I, L>
+impl<Context> Format<Context> for FormatSkippedTokenTrivia<'_, Context::Language>
 where
-    I: Iterator<Item = SourceComment<L>> + Clone,
-    C: CstFormatContext<Language = L>,
+    Context: CstFormatContext,
 {
-    fn fmt(&self, f: &mut Formatter<C>) -> FormatResult<()> {
-        let comments = self.comments.clone();
-        let mut last_inline_comment = f.state().is_last_content_inline_comment();
-
-        for (index, comment) in comments.enumerate() {
-            if !self.skip_formatted_check && f.state().is_comment_formatted(comment.piece()) {
-                continue;
-            }
-
-            #[allow(deprecated)]
-            let kind = f
-                .context()
-                .comment_style()
-                .get_comment_kind(comment.piece());
-            last_inline_comment = kind.is_inline();
-            let is_single_line = kind.is_line();
-
-            let content = format_with(|f: &mut Formatter<C>| {
-                if !is_single_line {
-                    match self.token_kind {
-                        // Don't write a space if this is a group start token and it isn't the first trailing comment
-                        #[allow(deprecated)]
-                        Some(token)
-                            if f.context().comment_style().is_group_start_token(token)
-                                && index == 0 => {}
-                        //  Write a space for all other cases
-                        _ => space().fmt(f)?,
-                    }
-                    comment.piece().fmt(f)
-                } else {
-                    write![
-                        f,
-                        [
-                            line_suffix(&format_args![space(), comment.piece()]),
-                            expand_parent()
-                        ]
-                    ]
-                }
-            });
-
-            crate::comment(&content).fmt(f)?;
+    fn fmt(&self, f: &mut Formatter<Context>) -> FormatResult<()> {
+        if f.comments().has_skipped(self.token) {
+            self.fmt_skipped(f)
+        } else {
+            Ok(())
         }
-
-        f.state_mut()
-            .set_last_content_inline_comment(last_inline_comment);
-
-        Ok(())
     }
 }
diff --git a/crates/rome_formatter/src/verbatim.rs b/crates/rome_formatter/src/verbatim.rs
index dcf35785335..c0b6ed8e7d1 100644
--- a/crates/rome_formatter/src/verbatim.rs
+++ b/crates/rome_formatter/src/verbatim.rs
@@ -1,5 +1,5 @@
-use crate::cst::{FormatLeadingComments, FormatTrailingComments};
 use crate::prelude::*;
+use crate::token::{FormatLeadingComments, FormatTrailingComments};
 use crate::VecBuffer;
 use crate::{write, CstFormatContext};
 use rome_rowan::{Direction, Language, SyntaxElement, SyntaxNode, TextRange};

From ba0fb8bb260a6d5020b1174360dcf25437297101 Mon Sep 17 00:00:00 2001
From: Micha Reiser <micha@rome.tools>
Date: Fri, 16 Sep 2022 15:12:06 +0200
Subject: [PATCH 09/15] Documentation and naming

---
 crates/rome_formatter/src/builders.rs         | 57 +++++++++++++++++
 crates/rome_formatter/src/formatter.rs        |  1 +
 crates/rome_formatter/src/lib.rs              |  2 +-
 crates/rome_formatter/src/prelude.rs          |  2 +-
 crates/rome_formatter/src/source_map.rs       |  3 +-
 .../src/{token.rs => trivia.rs}               | 64 +++++++++++++++----
 crates/rome_formatter/src/verbatim.rs         |  2 +-
 7 files changed, 113 insertions(+), 18 deletions(-)
 rename crates/rome_formatter/src/{token.rs => trivia.rs} (90%)

diff --git a/crates/rome_formatter/src/builders.rs b/crates/rome_formatter/src/builders.rs
index a4ccdf0060f..bcef1381810 100644
--- a/crates/rome_formatter/src/builders.rs
+++ b/crates/rome_formatter/src/builders.rs
@@ -1127,6 +1127,63 @@ impl<Context> std::fmt::Debug for BlockIndent<'_, Context> {
     }
 }
 
+/// Adds spaces around the content if its enclosing group fits on a line, otherwise indents the content and separates it by line breaks.
+///
+/// # Examples
+///
+/// Adds line breaks and indents the content if the enclosing group doesn't fit on the line.
+///
+/// ```
+/// use rome_formatter::{format, format_args, LineWidth, SimpleFormatOptions};
+/// use rome_formatter::prelude::*;
+///
+/// let context = SimpleFormatContext::new(SimpleFormatOptions {
+///     line_width: LineWidth::try_from(10).unwrap(),
+///     ..SimpleFormatOptions::default()
+/// });
+///
+/// let elements = format!(context, [
+///     group(&format_args![
+///         text("{"),
+///         soft_line_indent_or_spaced(&format_args![
+///             text("aPropertyThatExceeds"),
+///             text(":"),
+///             space(),
+///             text("'line width'"),
+///         ]),
+///         text("}")
+///     ])
+/// ]).unwrap();
+///
+/// assert_eq!(
+///     "{\n\taPropertyThatExceeds: 'line width'\n}",
+///     elements.print().as_code()
+/// );
+/// ```
+///
+/// Adds spaces around the content if the group fits on the line
+/// ```
+/// use rome_formatter::{format, format_args};
+/// use rome_formatter::prelude::*;
+///
+/// let elements = format!(SimpleFormatContext::default(), [
+///     group(&format_args![
+///         text("{"),
+///         soft_line_indent_or_spaced(&format_args![
+///             text("a"),
+///             text(":"),
+///             space(),
+///             text("5"),
+///         ]),
+///         text("}")
+///     ])
+/// ]).unwrap();
+///
+/// assert_eq!(
+///     "{ a: 5 }",
+///     elements.print().as_code()
+/// );
+/// ```
 pub fn soft_line_indent_or_spaced<Context>(
     content: &impl Format<Context>,
 ) -> SoftLineIndentOrSpaced<Context> {
diff --git a/crates/rome_formatter/src/formatter.rs b/crates/rome_formatter/src/formatter.rs
index 897433cd0cb..df248c3d029 100644
--- a/crates/rome_formatter/src/formatter.rs
+++ b/crates/rome_formatter/src/formatter.rs
@@ -218,6 +218,7 @@ impl<Context> Formatter<'_, Context>
 where
     Context: CstFormatContext,
 {
+    /// Returns the comments from the context.
     pub fn comments(&self) -> &Comments<Context::Language> {
         self.context().comments()
     }
diff --git a/crates/rome_formatter/src/lib.rs b/crates/rome_formatter/src/lib.rs
index 18e06cf9813..61709ed8aa3 100644
--- a/crates/rome_formatter/src/lib.rs
+++ b/crates/rome_formatter/src/lib.rs
@@ -36,7 +36,7 @@ pub mod prelude;
 pub mod printed_tokens;
 pub mod printer;
 mod source_map;
-pub mod token;
+pub mod trivia;
 mod verbatim;
 
 use crate::formatter::Formatter;
diff --git a/crates/rome_formatter/src/prelude.rs b/crates/rome_formatter/src/prelude.rs
index 80fdc7beafa..cfaf2c02a3c 100644
--- a/crates/rome_formatter/src/prelude.rs
+++ b/crates/rome_formatter/src/prelude.rs
@@ -3,7 +3,7 @@ pub use crate::format_element::*;
 pub use crate::format_extensions::{FormatOptional as _, MemoizeFormat, Memoized};
 pub use crate::formatter::Formatter;
 pub use crate::printer::PrinterOptions;
-pub use crate::token::{
+pub use crate::trivia::{
     format_dangling_comments, format_leading_comments, format_only_if_breaks, format_removed,
     format_replaced, format_trailing_comments, format_trimmed_token,
 };
diff --git a/crates/rome_formatter/src/source_map.rs b/crates/rome_formatter/src/source_map.rs
index 7d1439f51c8..786f606ec0f 100644
--- a/crates/rome_formatter/src/source_map.rs
+++ b/crates/rome_formatter/src/source_map.rs
@@ -382,13 +382,14 @@ pub struct TransformSourceMapBuilder {
 }
 
 impl TransformSourceMapBuilder {
-    /// Creates a new builder for a source map that maps positions back to the passed `root` tree.
+    /// Creates a new builder.
     pub fn new() -> Self {
         Self {
             ..Default::default()
         }
     }
 
+    /// Creates a new builder for a document with the given source.
     pub fn with_source(source: String) -> Self {
         Self {
             source_text: source,
diff --git a/crates/rome_formatter/src/token.rs b/crates/rome_formatter/src/trivia.rs
similarity index 90%
rename from crates/rome_formatter/src/token.rs
rename to crates/rome_formatter/src/trivia.rs
index aff140e6ced..1a51bb41414 100644
--- a/crates/rome_formatter/src/token.rs
+++ b/crates/rome_formatter/src/trivia.rs
@@ -1,12 +1,13 @@
+//! Provides builders for comments and skipped token trivia.
+
 use crate::prelude::*;
 use crate::{
-    write, Argument, Arguments, CommentKind, CommentStyle, CstFormatContext, FormatRefWithRule,
-    GroupId, SourceComment, TextRange, VecBuffer,
+    comments::{CommentKind, CommentStyle},
+    write, Argument, Arguments, CstFormatContext, FormatRefWithRule, GroupId, SourceComment,
+    TextRange, VecBuffer,
 };
 use rome_rowan::{Language, SyntaxNode, SyntaxToken};
 
-///! Provides builders for formatting a CST.
-
 /// Formats the leading comments of `node`
 pub const fn format_leading_comments<L: Language>(
     node: &SyntaxNode<L>,
@@ -134,6 +135,7 @@ where
     }
 }
 
+/// Formats the dangling comments of `node`.
 pub const fn format_dangling_comments<L: Language>(
     node: &SyntaxNode<L>,
 ) -> FormatDanglingComments<L> {
@@ -157,16 +159,51 @@ pub enum FormatDanglingComments<'a, L: Language> {
 
 #[derive(Copy, Clone, Debug)]
 pub enum DanglingIndentMode {
+    /// Writes every comment on its own line and indents them with a block indent.
+    ///
+    /// # Examples
+    /// ```ignore
+    /// [
+    ///     /* comment */
+    /// ]
+    ///
+    /// [
+    ///     /* comment */
+    ///     /* multiple */
+    /// ]
+    /// ```
     Block,
+
+    /// Writes every comment on its own line and indents them with a soft line indent.
+    /// Guarantees to write a line break if the last formatted comment is a [line](CommentKind::Line) comment.
+    ///
+    /// # Examples
+    ///
+    /// ```ignore
+    /// [/* comment */]
+    ///
+    /// [
+    ///     /* comment */
+    ///     /* other */
+    /// ]
+    ///
+    /// [
+    ///     // line
+    /// ]
+    /// ```
     Soft,
+
+    /// Writes every comment on its own line.
     None,
 }
 
 impl<L: Language> FormatDanglingComments<'_, L> {
+    /// Indents the comments with a [block](DanglingIndentMode::Block) indent.
     pub fn with_block_indent(self) -> Self {
         self.with_indent_mode(DanglingIndentMode::Block)
     }
 
+    /// Indents the comments with a [soft block](DanglingIndentMode::Soft) indent.
     pub fn with_soft_block_indent(self) -> Self {
         self.with_indent_mode(DanglingIndentMode::Soft)
     }
@@ -239,10 +276,10 @@ where
     }
 }
 
-/// Formats a token without its leading or trailing trivia
+/// Formats a token without its skipped token trivia
 ///
 /// ## Warning
-/// It's your responsibility to format leading or trailing comments and skipped trivia.
+/// It's your responsibility to format any skipped trivia.
 pub const fn format_trimmed_token<L: Language>(token: &SyntaxToken<L>) -> FormatTrimmedToken<L> {
     FormatTrimmedToken { token }
 }
@@ -261,10 +298,7 @@ where
         syntax_token_text_slice(self.token, trimmed_range).fmt(f)
     }
 }
-/// Formats the leading and trailing trivia of a removed token.
-///
-/// Formats all leading and trailing comments up to the first line break or skipped token trivia as a trailing
-/// comment of the previous token. The remaining trivia is then printed as leading trivia of the next token.
+/// Formats the skipped token trivia of a removed token and marks the token as tracked.
 pub const fn format_removed<L>(token: &SyntaxToken<L>) -> FormatRemoved<L>
 where
     L: Language,
@@ -295,7 +329,7 @@ where
 
 /// Print out a `token` from the original source with a different `content`.
 ///
-/// This will print the trivia that belong to `token` to `content`;
+/// This will print the skipped token trivia that belong to `token` to `content`;
 /// `token` is then marked as consumed by the formatter.
 pub fn format_replaced<'a, 'content, L, Context>(
     token: &'a SyntaxToken<L>,
@@ -310,7 +344,7 @@ where
     }
 }
 
-/// Formats a token's leading and trailing trivia but uses the provided content instead
+/// Formats a token's skipped token trivia but uses the provided content instead
 /// of the token in the formatted output.
 #[derive(Copy, Clone)]
 pub struct FormatReplaced<'a, 'content, L, C>
@@ -335,7 +369,7 @@ where
     }
 }
 
-/// Formats the given token only if the group does break and otherwise retains the token's trivia.
+/// Formats the given token only if the group does break and otherwise retains the token's skipped token trivia.
 pub fn format_only_if_breaks<'a, 'content, L, Content, Context>(
     token: &'a SyntaxToken<L>,
     content: &'content Content,
@@ -351,7 +385,7 @@ where
     }
 }
 
-/// Formats a token with its leading and trailing trivia that only gets printed if its enclosing
+/// Formats a token with its skipped token trivia that only gets printed if its enclosing
 /// group does break but otherwise gets omitted from the formatted output.
 pub struct FormatOnlyIfBreaks<'a, 'content, L, C>
 where
@@ -390,12 +424,14 @@ where
     }
 }
 
+/// Formats the skipped token trivia of `token`.
 pub const fn format_skipped_token_trivia<L: Language>(
     token: &SyntaxToken<L>,
 ) -> FormatSkippedTokenTrivia<L> {
     FormatSkippedTokenTrivia { token }
 }
 
+/// Formats the skipped token trivia of `token`.
 pub struct FormatSkippedTokenTrivia<'a, L: Language> {
     token: &'a SyntaxToken<L>,
 }
diff --git a/crates/rome_formatter/src/verbatim.rs b/crates/rome_formatter/src/verbatim.rs
index c0b6ed8e7d1..782503d22c1 100644
--- a/crates/rome_formatter/src/verbatim.rs
+++ b/crates/rome_formatter/src/verbatim.rs
@@ -1,5 +1,5 @@
 use crate::prelude::*;
-use crate::token::{FormatLeadingComments, FormatTrailingComments};
+use crate::trivia::{FormatLeadingComments, FormatTrailingComments};
 use crate::VecBuffer;
 use crate::{write, CstFormatContext};
 use rome_rowan::{Direction, Language, SyntaxElement, SyntaxNode, TextRange};

From eae6f8b0a2556c8a382e39d9d412ee6264616ab4 Mon Sep 17 00:00:00 2001
From: Micha Reiser <micha@rome.tools>
Date: Mon, 19 Sep 2022 16:48:24 +0200
Subject: [PATCH 10/15] Update crates/rome_formatter/src/comments.rs

Co-authored-by: l3ops <leops@users.noreply.github.com>
---
 crates/rome_formatter/src/comments.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/rome_formatter/src/comments.rs b/crates/rome_formatter/src/comments.rs
index ea6dd93e3a1..711f9a2f1e6 100644
--- a/crates/rome_formatter/src/comments.rs
+++ b/crates/rome_formatter/src/comments.rs
@@ -365,7 +365,7 @@ impl<L: Language> DecoratedComment<L> {
         self.following.take()
     }
 
-    /// The number of lines between this comment and the **previous** token or comment.
+    /// The number of line breaks between this comment and the **previous** token or comment.
     ///
     /// # Examples
     ///

From f42e894ebfc79fff91a84136bf66806e3053f47a Mon Sep 17 00:00:00 2001
From: Micha Reiser <micha@rome.tools>
Date: Tue, 20 Sep 2022 14:28:36 +0200
Subject: [PATCH 11/15] Rename `soft_line_indent_or_spaced` to
 `soft_space_or_block_indent`

---
 crates/rome_formatter/src/builders.rs | 47 +++++++--------------------
 1 file changed, 11 insertions(+), 36 deletions(-)

diff --git a/crates/rome_formatter/src/builders.rs b/crates/rome_formatter/src/builders.rs
index bcef1381810..d4158fcca85 100644
--- a/crates/rome_formatter/src/builders.rs
+++ b/crates/rome_formatter/src/builders.rs
@@ -1081,6 +1081,7 @@ pub struct BlockIndent<'a, Context> {
 enum IndentMode {
     Soft,
     Block,
+    SoftSpace,
     SoftLineOrSpace,
 }
 
@@ -1091,7 +1092,9 @@ impl<Context> Format<Context> for BlockIndent<'_, Context> {
         match self.mode {
             IndentMode::Soft => write!(buffer, [soft_line_break()])?,
             IndentMode::Block => write!(buffer, [hard_line_break()])?,
-            IndentMode::SoftLineOrSpace => write!(buffer, [soft_line_break_or_space()])?,
+            IndentMode::SoftLineOrSpace | IndentMode::SoftSpace => {
+                write!(buffer, [soft_line_break_or_space()])?
+            }
         };
 
         buffer.write_fmt(Arguments::from(&self.content))?;
@@ -1108,6 +1111,7 @@ impl<Context> Format<Context> for BlockIndent<'_, Context> {
         match self.mode {
             IndentMode::Soft => write!(f, [soft_line_break()])?,
             IndentMode::Block => write!(f, [hard_line_break()])?,
+            IndentMode::SoftSpace => write!(f, [soft_line_break_or_space()])?,
             IndentMode::SoftLineOrSpace => {}
         }
 
@@ -1121,6 +1125,7 @@ impl<Context> std::fmt::Debug for BlockIndent<'_, Context> {
             IndentMode::Soft => "SoftBlockIndent",
             IndentMode::Block => "HardBlockIndent",
             IndentMode::SoftLineOrSpace => "SoftLineIndentOrSpace",
+            IndentMode::SoftSpace => "SoftSpaceBlockIndent",
         };
 
         f.debug_tuple(name).field(&"{{content}}").finish()
@@ -1145,7 +1150,7 @@ impl<Context> std::fmt::Debug for BlockIndent<'_, Context> {
 /// let elements = format!(context, [
 ///     group(&format_args![
 ///         text("{"),
-///         soft_line_indent_or_spaced(&format_args![
+///         soft_space_or_block_indent(&format_args![
 ///             text("aPropertyThatExceeds"),
 ///             text(":"),
 ///             space(),
@@ -1169,7 +1174,7 @@ impl<Context> std::fmt::Debug for BlockIndent<'_, Context> {
 /// let elements = format!(SimpleFormatContext::default(), [
 ///     group(&format_args![
 ///         text("{"),
-///         soft_line_indent_or_spaced(&format_args![
+///         soft_space_or_block_indent(&format_args![
 ///             text("a"),
 ///             text(":"),
 ///             space(),
@@ -1184,40 +1189,10 @@ impl<Context> std::fmt::Debug for BlockIndent<'_, Context> {
 ///     elements.print().as_code()
 /// );
 /// ```
-pub fn soft_line_indent_or_spaced<Context>(
-    content: &impl Format<Context>,
-) -> SoftLineIndentOrSpaced<Context> {
-    SoftLineIndentOrSpaced {
+pub fn soft_space_or_block_indent<Context>(content: &impl Format<Context>) -> BlockIndent<Context> {
+    BlockIndent {
         content: Argument::new(content),
-    }
-}
-
-#[derive(Copy, Clone)]
-pub struct SoftLineIndentOrSpaced<'a, Context> {
-    content: Argument<'a, Context>,
-}
-
-impl<Context> Format<Context> for SoftLineIndentOrSpaced<'_, Context> {
-    fn fmt(&self, f: &mut Formatter<Context>) -> FormatResult<()> {
-        let mut is_empty = true;
-
-        let format_content = format_once(|f| {
-            let mut recording = f.start_recording();
-
-            recording.write_fmt(Arguments::from(&self.content))?;
-
-            is_empty = recording.stop().is_empty();
-
-            Ok(())
-        });
-
-        soft_line_indent_or_space(&format_content).fmt(f)?;
-
-        if !is_empty {
-            soft_line_break_or_space().fmt(f)?;
-        }
-
-        Ok(())
+        mode: IndentMode::SoftSpace,
     }
 }
 

From 0abbbb640da494a19e242abc30a02c4ceba52543 Mon Sep 17 00:00:00 2001
From: Micha Reiser <micha@rome.tools>
Date: Thu, 15 Sep 2022 13:45:13 +0200
Subject: [PATCH 12/15] refactor(rome_js_formatter): Part 6: JS Comments
 formatting

---
 crates/rome_js_formatter/src/comments.rs      | 1049 ++++++++++++++++-
 crates/rome_js_formatter/src/context.rs       |   17 +-
 crates/rome_js_formatter/src/generated.rs     |   22 +-
 crates/rome_js_formatter/src/lib.rs           |   99 +-
 crates/rome_js_formatter/src/prelude.rs       |    9 +-
 crates/rome_js_formatter/src/separated.rs     |   14 +-
 .../rome_js_formatter/src/syntax_rewriter.rs  |  132 ++-
 7 files changed, 1236 insertions(+), 106 deletions(-)

diff --git a/crates/rome_js_formatter/src/comments.rs b/crates/rome_js_formatter/src/comments.rs
index 811c9a44f9b..1424e0325fd 100644
--- a/crates/rome_js_formatter/src/comments.rs
+++ b/crates/rome_js_formatter/src/comments.rs
@@ -1,9 +1,22 @@
 use crate::prelude::*;
-use rome_formatter::write;
-use rome_formatter::{CommentKind, CommentStyle, SourceComment};
+use crate::utils::JsAnyConditional;
+use rome_formatter::{
+    comments::{
+        CommentKind, CommentPlacement, CommentStyle, CommentTextPosition, Comments,
+        DecoratedComment, SourceComment,
+    },
+    write,
+};
 use rome_js_syntax::suppression::{parse_suppression_comment, SuppressionCategory};
-use rome_js_syntax::{JsLanguage, JsSyntaxKind};
-use rome_rowan::{SyntaxTriviaPieceComments, TextLen};
+use rome_js_syntax::{
+    JsAnyClass, JsAnyName, JsAnyRoot, JsAnyStatement, JsArrayHole, JsArrowFunctionExpression,
+    JsBlockStatement, JsCallArguments, JsCatchClause, JsEmptyStatement, JsFinallyClause,
+    JsFormalParameter, JsFunctionBody, JsIdentifierExpression, JsIfStatement, JsLanguage,
+    JsSyntaxKind, JsSyntaxNode, JsVariableDeclarator, JsWhileStatement, TsInterfaceDeclaration,
+};
+use rome_rowan::{AstNode, SyntaxTriviaPieceComments, TextLen};
+
+pub type JsComments = Comments<JsLanguage>;
 
 #[derive(Default)]
 pub struct FormatJsLeadingComment;
@@ -47,7 +60,7 @@ impl FormatRule<SourceComment<JsLanguage>> for FormatJsLeadingComment {
                 )]
             )
         } else {
-            write!(f, [comment.piece()])
+            write!(f, [comment.piece().as_piece()])
         }
     }
 }
@@ -117,14 +130,16 @@ pub fn is_doc_comment(comment: &SyntaxTriviaPieceComments<JsLanguage>) -> bool {
 #[derive(Eq, PartialEq, Copy, Clone, Debug, Default)]
 pub struct JsCommentStyle;
 
-impl CommentStyle<JsLanguage> for JsCommentStyle {
-    fn is_suppression(&self, text: &str) -> bool {
+impl CommentStyle for JsCommentStyle {
+    type Language = JsLanguage;
+
+    fn is_suppression(text: &str) -> bool {
         parse_suppression_comment(text)
             .flat_map(|suppression| suppression.categories)
             .any(|(category, _)| category == SuppressionCategory::Format)
     }
 
-    fn get_comment_kind(&self, comment: &SyntaxTriviaPieceComments<JsLanguage>) -> CommentKind {
+    fn get_comment_kind(comment: &SyntaxTriviaPieceComments<JsLanguage>) -> CommentKind {
         if comment.text().starts_with("/*") {
             if comment.has_newline() {
                 CommentKind::Block
@@ -136,26 +151,1010 @@ impl CommentStyle<JsLanguage> for JsCommentStyle {
         }
     }
 
-    fn is_group_start_token(&self, kind: JsSyntaxKind) -> bool {
-        matches!(
-            kind,
-            JsSyntaxKind::L_PAREN
-                | JsSyntaxKind::L_BRACK
-                | JsSyntaxKind::L_CURLY
-                | JsSyntaxKind::DOLLAR_CURLY
-        )
+    fn place_comment(
+        &self,
+        comment: DecoratedComment<Self::Language>,
+    ) -> CommentPlacement<Self::Language> {
+        match comment.text_position() {
+            CommentTextPosition::EndOfLine => handle_typecast_comment(comment)
+                .or_else(handle_function_declaration_comment)
+                .or_else(handle_conditional_comment)
+                .or_else(handle_if_statement_comment)
+                .or_else(handle_while_comment)
+                .or_else(handle_try_comment)
+                .or_else(handle_class_comment)
+                .or_else(handle_method_comment)
+                .or_else(handle_for_comment)
+                .or_else(handle_root_comments)
+                .or_else(handle_array_hole_comment)
+                .or_else(handle_variable_declarator_comment)
+                .or_else(handle_parameter_comment)
+                .or_else(handle_labelled_statement_comment)
+                .or_else(handle_call_expression_comment)
+                .or_else(handle_continue_break_comment)
+                .or_else(handle_mapped_type_comment)
+                .or_else(handle_switch_default_case_comment)
+                .or_else(handle_import_export_specifier_comment),
+            CommentTextPosition::OwnLine => handle_member_expression_comment(comment)
+                .or_else(handle_function_declaration_comment)
+                .or_else(handle_if_statement_comment)
+                .or_else(handle_while_comment)
+                .or_else(handle_try_comment)
+                .or_else(handle_class_comment)
+                .or_else(handle_method_comment)
+                .or_else(handle_for_comment)
+                .or_else(handle_root_comments)
+                .or_else(handle_parameter_comment)
+                .or_else(handle_array_hole_comment)
+                .or_else(handle_labelled_statement_comment)
+                .or_else(handle_call_expression_comment)
+                .or_else(handle_mapped_type_comment)
+                .or_else(handle_continue_break_comment)
+                .or_else(handle_union_type_comment)
+                .or_else(handle_import_export_specifier_comment),
+            CommentTextPosition::SameLine => handle_if_statement_comment(comment)
+                .or_else(handle_while_comment)
+                .or_else(handle_for_comment)
+                .or_else(handle_root_comments)
+                .or_else(handle_after_arrow_param_comment)
+                .or_else(handle_array_hole_comment)
+                .or_else(handle_call_expression_comment)
+                .or_else(handle_continue_break_comment)
+                .or_else(handle_class_comment),
+        }
+    }
+}
+
+/// Force end of line type cast comments to remain leading comments of the next node, if any
+fn handle_typecast_comment(comment: DecoratedComment<JsLanguage>) -> CommentPlacement<JsLanguage> {
+    match comment.following_node() {
+        Some(following_node) if is_type_comment(comment.piece()) => {
+            CommentPlacement::leading(following_node.clone(), comment)
+        }
+        _ => CommentPlacement::Default(comment),
+    }
+}
+
+fn handle_after_arrow_param_comment(
+    comment: DecoratedComment<JsLanguage>,
+) -> CommentPlacement<JsLanguage> {
+    let is_next_arrow = comment.following_token().kind() == JsSyntaxKind::FAT_ARROW;
+
+    // Makes comments after the `(` and `=>` dangling comments
+    // ```javascript
+    // () /* comment */ => true
+    // ```
+    if JsArrowFunctionExpression::can_cast(comment.enclosing_node().kind()) && is_next_arrow {
+        CommentPlacement::dangling(comment.enclosing_node().clone(), comment)
+    } else {
+        CommentPlacement::Default(comment)
+    }
+}
+
+/// Handles array hole comments. Array holes have no token so all comments
+/// become trailing comments by default. Override it that all comments are leading comments.
+fn handle_array_hole_comment(
+    comment: DecoratedComment<JsLanguage>,
+) -> CommentPlacement<JsLanguage> {
+    if let Some(array_hole) = comment.preceding_node().and_then(JsArrayHole::cast_ref) {
+        CommentPlacement::leading(array_hole.into_syntax(), comment)
+    } else {
+        CommentPlacement::Default(comment)
+    }
+}
+
+fn handle_call_expression_comment(
+    comment: DecoratedComment<JsLanguage>,
+) -> CommentPlacement<JsLanguage> {
+    // Make comments between the callee and the arguments leading comments of the first argument.
+    // ```javascript
+    // a /* comment */ (call)
+    // ```
+    if let Some(arguments) = comment.following_node().and_then(JsCallArguments::cast_ref) {
+        return if let Some(Ok(first)) = arguments.args().first() {
+            CommentPlacement::leading(first.into_syntax(), comment)
+        } else {
+            CommentPlacement::dangling(arguments.into_syntax(), comment)
+        };
+    }
+
+    CommentPlacement::Default(comment)
+}
+
+fn handle_continue_break_comment(
+    comment: DecoratedComment<JsLanguage>,
+) -> CommentPlacement<JsLanguage> {
+    let enclosing = comment.enclosing_node();
+
+    // Make comments between the `continue` and label token trailing comments
+    // ```javascript
+    // continue /* comment */ a;
+    // ```
+    // This differs from Prettier because other ASTs use an identifier for the label whereas Rome uses
+    // a token.
+    match enclosing.kind() {
+        JsSyntaxKind::JS_CONTINUE_STATEMENT | JsSyntaxKind::JS_BREAK_STATEMENT => {
+            match enclosing.parent() {
+                // Make it the trailing of the parent if this is a single-statement body
+                // to prevent that the comment becomes a trailing comment of the parent when re-formatting
+                // ```javascript
+                // for (;;) continue /* comment */;
+                // ```
+                Some(parent)
+                    if matches!(
+                        parent.kind(),
+                        JsSyntaxKind::JS_FOR_STATEMENT
+                            | JsSyntaxKind::JS_FOR_OF_STATEMENT
+                            | JsSyntaxKind::JS_FOR_IN_STATEMENT
+                            | JsSyntaxKind::JS_WHILE_STATEMENT
+                            | JsSyntaxKind::JS_DO_WHILE_STATEMENT
+                            | JsSyntaxKind::JS_IF_STATEMENT
+                            | JsSyntaxKind::JS_WITH_STATEMENT
+                            | JsSyntaxKind::JS_LABELED_STATEMENT
+                    ) =>
+                {
+                    CommentPlacement::trailing(parent, comment)
+                }
+                _ => CommentPlacement::trailing(enclosing.clone(), comment),
+            }
+        }
+        _ => CommentPlacement::Default(comment),
     }
+}
+
+/// Moves line comments after the `default` keyword into the block statement:
+///
+/// ```javascript
+/// switch (x) {
+///     default: // comment
+///     {
+///         break;
+///     }
+/// ```
+///
+/// All other same line comments become `Dangling` comments that are handled inside of the default case
+/// formatting
+fn handle_switch_default_case_comment(
+    comment: DecoratedComment<JsLanguage>,
+) -> CommentPlacement<JsLanguage> {
+    match (comment.enclosing_node().kind(), comment.following_node()) {
+        (JsSyntaxKind::JS_DEFAULT_CLAUSE, Some(following)) => {
+            match JsBlockStatement::cast_ref(following) {
+                Some(block) if comment.kind().is_line() => {
+                    place_block_statement_comment(block, comment)
+                }
+                _ => CommentPlacement::dangling(comment.enclosing_node().clone(), comment),
+            }
+        }
+        _ => CommentPlacement::Default(comment),
+    }
+}
+
+fn handle_labelled_statement_comment(
+    comment: DecoratedComment<JsLanguage>,
+) -> CommentPlacement<JsLanguage> {
+    match comment.enclosing_node().kind() {
+        JsSyntaxKind::JS_LABELED_STATEMENT => {
+            CommentPlacement::leading(comment.enclosing_node().clone(), comment)
+        }
+        _ => CommentPlacement::Default(comment),
+    }
+}
+
+fn handle_class_comment(comment: DecoratedComment<JsLanguage>) -> CommentPlacement<JsLanguage> {
+    // Make comments following after the `extends` or `implements` keyword trailing comments
+    // of the preceding extends, type parameters, or id.
+    // ```javascript
+    // class a9 extends
+    //   /* comment */
+    // b {
+    //   constructor() {}
+    // }
+    // ```
+    if matches!(
+        comment.enclosing_node().kind(),
+        JsSyntaxKind::JS_EXTENDS_CLAUSE
+            | JsSyntaxKind::TS_IMPLEMENTS_CLAUSE
+            | JsSyntaxKind::TS_EXTENDS_CLAUSE
+    ) {
+        if comment.preceding_node().is_none() && !comment.text_position().is_same_line() {
+            if let Some(sibling) = comment.enclosing_node().prev_sibling() {
+                return CommentPlacement::trailing(sibling, comment);
+            }
+        }
+
+        return CommentPlacement::Default(comment);
+    }
+
+    let first_member = if let Some(class) = JsAnyClass::cast_ref(comment.enclosing_node()) {
+        class.members().first().map(AstNode::into_syntax)
+    } else if let Some(interface) = TsInterfaceDeclaration::cast_ref(comment.enclosing_node()) {
+        interface.members().first().map(AstNode::into_syntax)
+    } else {
+        return CommentPlacement::Default(comment);
+    };
+
+    if comment.text_position().is_same_line() {
+        // Handle same line comments in empty class bodies
+        // ```javascript
+        // class Test { /* comment */ }
+        // ```
+        if comment.following_token().kind() == JsSyntaxKind::R_CURLY && first_member.is_none() {
+            return CommentPlacement::dangling(comment.enclosing_node().clone(), comment);
+        } else {
+            return CommentPlacement::Default(comment);
+        }
+    }
+
+    if let Some(following) = comment.following_node() {
+        // Make comments preceding the first member leading comments of the member
+        // ```javascript
+        // class Test { /* comment */
+        //      prop;
+        // }
+        // ```
+        if let Some(member) = first_member {
+            if following == &member {
+                return CommentPlacement::leading(member, comment);
+            }
+        }
+
+        if let Some(preceding) = comment.preceding_node() {
+            // Make all comments between the id/type parameters and the extends clause trailing comments
+            // of the id/type parameters
+            //
+            // ```javascript
+            // class Test
+            //
+            // /* comment */ extends B {}
+            // ```
+            if matches!(
+                following.kind(),
+                JsSyntaxKind::JS_EXTENDS_CLAUSE
+                    | JsSyntaxKind::TS_IMPLEMENTS_CLAUSE
+                    | JsSyntaxKind::TS_EXTENDS_CLAUSE
+            ) && !comment.text_position().is_same_line()
+            {
+                return CommentPlacement::trailing(preceding.clone(), comment);
+            }
+        }
+    } else if first_member.is_none() {
+        // Handle the case where there are no members, attach the comments as dangling comments.
+        // ```javascript
+        // class Test // comment
+        // {
+        // }
+        // ```
+        return CommentPlacement::dangling(comment.enclosing_node().clone(), comment);
+    }
+
+    CommentPlacement::Default(comment)
+}
+
+fn handle_method_comment(comment: DecoratedComment<JsLanguage>) -> CommentPlacement<JsLanguage> {
+    let enclosing = comment.enclosing_node();
+
+    let is_method = matches!(
+        enclosing.kind(),
+        JsSyntaxKind::JS_METHOD_CLASS_MEMBER
+            | JsSyntaxKind::JS_METHOD_OBJECT_MEMBER
+            | JsSyntaxKind::JS_SETTER_CLASS_MEMBER
+            | JsSyntaxKind::JS_GETTER_CLASS_MEMBER
+            | JsSyntaxKind::JS_SETTER_OBJECT_MEMBER
+            | JsSyntaxKind::JS_GETTER_OBJECT_MEMBER
+            | JsSyntaxKind::JS_CONSTRUCTOR_CLASS_MEMBER
+    );
+
+    if !is_method {
+        return CommentPlacement::Default(comment);
+    }
+
+    // Move end of line and own line comments before the method body into the function
+    // ```javascript
+    // class Test {
+    //   method() /* test */
+    //  {}
+    // }
+    // ```
+    if let Some(following) = comment.following_node() {
+        if let Some(body) = JsFunctionBody::cast_ref(following) {
+            if let Some(directive) = body.directives().first() {
+                return CommentPlacement::leading(directive.into_syntax(), comment);
+            }
+
+            let first_non_empty = body
+                .statements()
+                .iter()
+                .find(|statement| !matches!(statement, JsAnyStatement::JsEmptyStatement(_)));
+
+            return match first_non_empty {
+                None => CommentPlacement::dangling(body.into_syntax(), comment),
+                Some(statement) => CommentPlacement::leading(statement.into_syntax(), comment),
+            };
+        }
+    }
+
+    CommentPlacement::Default(comment)
+}
+
+/// Handle a all comments document.
+/// See `blank.js`
+fn handle_root_comments(comment: DecoratedComment<JsLanguage>) -> CommentPlacement<JsLanguage> {
+    if let Some(root) = JsAnyRoot::cast_ref(comment.enclosing_node()) {
+        let is_blank = match &root {
+            JsAnyRoot::JsExpressionSnipped(_) => false,
+            JsAnyRoot::JsModule(module) => {
+                module.directives().is_empty() && module.items().is_empty()
+            }
+            JsAnyRoot::JsScript(script) => {
+                script.directives().is_empty() && script.statements().is_empty()
+            }
+        };
+
+        if is_blank {
+            return CommentPlacement::leading(root.into_syntax(), comment);
+        }
+    }
+
+    CommentPlacement::Default(comment)
+}
+
+fn handle_member_expression_comment(
+    comment: DecoratedComment<JsLanguage>,
+) -> CommentPlacement<JsLanguage> {
+    let following = match comment.following_node() {
+        Some(following)
+            if matches!(
+                comment.enclosing_node().kind(),
+                JsSyntaxKind::JS_STATIC_MEMBER_EXPRESSION
+                    | JsSyntaxKind::JS_COMPUTED_MEMBER_EXPRESSION
+            ) =>
+        {
+            following
+        }
+        _ => return CommentPlacement::Default(comment),
+    };
+
+    // ```javascript
+    // a
+    // /* comment */.b
+    // a
+    // /* comment */[b]
+    // ```
+    if JsAnyName::can_cast(following.kind()) || JsIdentifierExpression::can_cast(following.kind()) {
+        CommentPlacement::leading(comment.enclosing_node().clone(), comment)
+    } else {
+        CommentPlacement::Default(comment)
+    }
+}
+
+fn handle_function_declaration_comment(
+    comment: DecoratedComment<JsLanguage>,
+) -> CommentPlacement<JsLanguage> {
+    let is_function_declaration = matches!(
+        comment.enclosing_node().kind(),
+        JsSyntaxKind::JS_FUNCTION_DECLARATION
+            | JsSyntaxKind::JS_FUNCTION_EXPORT_DEFAULT_DECLARATION
+    );
+
+    let following = match comment.following_node() {
+        Some(following) if is_function_declaration => following,
+        _ => return CommentPlacement::Default(comment),
+    };
+
+    // Make comments between the `)` token and the function body leading comments
+    // of the first non empty statement or dangling comments of the body.
+    // ```javascript
+    // function test() /* comment */ {
+    //  console.log("Hy");
+    // }
+    // ```
+    if let Some(body) = JsFunctionBody::cast_ref(following) {
+        match body
+            .statements()
+            .iter()
+            .find(|statement| !matches!(statement, JsAnyStatement::JsEmptyStatement(_)))
+        {
+            Some(first) => CommentPlacement::leading(first.into_syntax(), comment),
+            None => CommentPlacement::dangling(body.into_syntax(), comment),
+        }
+    } else {
+        CommentPlacement::Default(comment)
+    }
+}
+
+fn handle_conditional_comment(
+    comment: DecoratedComment<JsLanguage>,
+) -> CommentPlacement<JsLanguage> {
+    let enclosing = comment.enclosing_node();
+
+    let (conditional, following) = match (
+        JsAnyConditional::cast_ref(enclosing),
+        comment.following_node(),
+    ) {
+        (Some(conditional), Some(following)) => (conditional, following),
+        _ => {
+            return CommentPlacement::Default(comment);
+        }
+    };
+
+    // Make end of line comments that come after the operator leading comments of the consequent / alternate.
+    // ```javascript
+    // a
+    //   // becomes leading of consequent
+    //   ? { x: 5 } :
+    //   {};
+    //
+    // a
+    //   ? { x: 5 }
+    //   : // becomes leading of alternate
+    // 	{};
+    //
+    // a // remains trailing, because it directly follows the node
+    //   ? { x: 5 }
+    //   : {};
+    // ```
+    let token = comment.piece().as_piece().token();
+    let is_after_operator = conditional.colon_token().as_ref() == Ok(&token)
+        || conditional.question_mark_token().as_ref() == Ok(&token);
+
+    if is_after_operator {
+        return CommentPlacement::leading(following.clone(), comment);
+    }
+
+    CommentPlacement::Default(comment)
+}
+
+fn handle_if_statement_comment(
+    comment: DecoratedComment<JsLanguage>,
+) -> CommentPlacement<JsLanguage> {
+    fn handle_else_clause(
+        comment: DecoratedComment<JsLanguage>,
+        consequent: JsSyntaxNode,
+        if_statement: JsSyntaxNode,
+    ) -> CommentPlacement<JsLanguage> {
+        // Make all comments trailing comments of the `consequent` if the `consequent` is a `JsBlockStatement`
+        // ```javascript
+        // if (test) {
+        //
+        // } /* comment */ else if (b) {
+        //     test
+        // }
+        // /* comment */ else if(c) {
+        //
+        // } /*comment */ else {
+        //
+        // }
+        // ```
+        if consequent.kind() == JsSyntaxKind::JS_BLOCK_STATEMENT {
+            return CommentPlacement::trailing(consequent, comment);
+        }
+
+        // Handle end of line comments that aren't stretching over multiple lines.
+        // Make them dangling comments of the consequent expression
+        //
+        // ```javascript
+        // if (cond1) expr1; // comment A
+        // else if (cond2) expr2; // comment A
+        // else expr3;
+        //
+        // if (cond1) expr1; /* comment */ else  expr2;
+        //
+        // if (cond1) expr1; /* b */
+        // else if (cond2) expr2; /* b */
+        // else expr3; /* b*/
+        // ```
+        if !comment.kind().is_block()
+            && !comment.text_position().is_own_line()
+            && comment.preceding_node().is_some()
+        {
+            return CommentPlacement::dangling(consequent, comment);
+        }
+
+        // ```javascript
+        // if (cond1) expr1;
+        //
+        // /* comment */ else  expr2;
+        //
+        // if (cond) expr; /*
+        // a multiline comment */
+        // else b;
+        //
+        // if (6) // comment
+        // true
+        // else // comment
+        // {true}
+        // ```
+        CommentPlacement::dangling(if_statement, comment)
+    }
+
+    match (comment.enclosing_node().kind(), comment.following_node()) {
+        (JsSyntaxKind::JS_IF_STATEMENT, Some(following)) => {
+            let if_statement = JsIfStatement::unwrap_cast(comment.enclosing_node().clone());
+
+            if let Some(preceding) = comment.preceding_node() {
+                // Test if this is a comment right before the condition's `)`
+                if comment.following_token().kind() == JsSyntaxKind::R_PAREN {
+                    return CommentPlacement::trailing(preceding.clone(), comment);
+                }
+
+                // Handle comments before `else`
+                if following.kind() == JsSyntaxKind::JS_ELSE_CLAUSE {
+                    let consequent = preceding.clone();
+                    let if_statement = comment.enclosing_node().clone();
+                    return handle_else_clause(comment, consequent, if_statement);
+                }
+            }
 
-    fn is_group_end_token(&self, kind: JsSyntaxKind) -> bool {
+            // Move comments coming before the `{` inside of the block
+            //
+            // ```javascript
+            // if (cond) /* test */ {
+            // }
+            // ```
+            if let Some(block_statement) = JsBlockStatement::cast_ref(following) {
+                return place_block_statement_comment(block_statement, comment);
+            }
+
+            // Don't attach comments to empty statements
+            // ```javascript
+            // if (cond) /* test */ ;
+            // ```
+            if let Some(preceding) = comment.preceding_node() {
+                if JsEmptyStatement::can_cast(following.kind()) {
+                    return CommentPlacement::trailing(preceding.clone(), comment);
+                }
+            }
+
+            // Move comments coming before an if chain inside the body of the first non chain if.
+            //
+            // ```javascript
+            // if (cond1)  /* test */ if (other) { a }
+            // ```
+            if let Some(if_statement) = JsIfStatement::cast_ref(following) {
+                if let Ok(nested_consequent) = if_statement.consequent() {
+                    return place_leading_statement_comment(nested_consequent, comment);
+                }
+            }
+
+            // Make all comments after the condition's `)` leading comments
+            // ```javascript
+            // if (5) // comment
+            // true
+            //
+            // ```
+            if let Ok(consequent) = if_statement.consequent() {
+                if consequent.syntax() == following {
+                    return CommentPlacement::leading(following.clone(), comment);
+                }
+            }
+        }
+        (JsSyntaxKind::JS_ELSE_CLAUSE, _) => {
+            if let Some(if_statement) = comment
+                .enclosing_node()
+                .parent()
+                .and_then(JsIfStatement::cast)
+            {
+                if let Ok(consequent) = if_statement.consequent() {
+                    return handle_else_clause(
+                        comment,
+                        consequent.into_syntax(),
+                        if_statement.into_syntax(),
+                    );
+                }
+            }
+        }
+        _ => {
+            // fall through
+        }
+    }
+
+    CommentPlacement::Default(comment)
+}
+
+fn handle_while_comment(comment: DecoratedComment<JsLanguage>) -> CommentPlacement<JsLanguage> {
+    let (while_statement, following) = match (
+        JsWhileStatement::cast_ref(comment.enclosing_node()),
+        comment.following_node(),
+    ) {
+        (Some(while_statement), Some(following)) => (while_statement, following),
+        _ => return CommentPlacement::Default(comment),
+    };
+
+    if let Some(preceding) = comment.preceding_node() {
+        // Test if this is a comment right before the condition's `)`
+        if comment.following_token().kind() == JsSyntaxKind::R_PAREN {
+            return CommentPlacement::trailing(preceding.clone(), comment);
+        }
+    }
+
+    // Move comments coming before the `{` inside of the block
+    //
+    // ```javascript
+    // while (cond) /* test */ {
+    // }
+    // ```
+    if let Some(block) = JsBlockStatement::cast_ref(following) {
+        return place_block_statement_comment(block, comment);
+    }
+
+    // Don't attach comments to empty statements
+    // ```javascript
+    // if (cond) /* test */ ;
+    // ```
+    if let Some(preceding) = comment.preceding_node() {
+        if JsEmptyStatement::can_cast(following.kind()) {
+            return CommentPlacement::trailing(preceding.clone(), comment);
+        }
+    }
+
+    // Make all comments after the condition's `)` leading comments
+    // ```javascript
+    // while (5) // comment
+    // true
+    //
+    // ```
+    if let Ok(body) = while_statement.body() {
+        if body.syntax() == following {
+            return CommentPlacement::leading(body.into_syntax(), comment);
+        }
+    }
+
+    CommentPlacement::Default(comment)
+}
+
+fn handle_try_comment(comment: DecoratedComment<JsLanguage>) -> CommentPlacement<JsLanguage> {
+    let following = match comment.following_node() {
+        Some(following)
+            if matches!(
+                comment.enclosing_node().kind(),
+                JsSyntaxKind::JS_TRY_STATEMENT | JsSyntaxKind::JS_TRY_FINALLY_STATEMENT
+            ) =>
+        {
+            // Move comments before the `catch` or `finally` inside of the body
+            // ```javascript
+            // try {
+            // }
+            //  catch(e) {
+            // }
+            // // Comment 7
+            // finally {}
+            // ```
+            let body = if let Some(catch) = JsCatchClause::cast_ref(following) {
+                catch.body()
+            } else if let Some(finally) = JsFinallyClause::cast_ref(following) {
+                finally.body()
+            } else {
+                // Use an err, so that the following code skips over it
+                Err(rome_rowan::SyntaxError::MissingRequiredChild)
+            };
+
+            //
+            // ```javascript
+            // try {
+            // } /* comment catch {
+            // }
+            // ```
+            if let Ok(body) = body {
+                return place_block_statement_comment(body, comment);
+            }
+
+            following
+        }
+        Some(following)
+            if matches!(
+                comment.enclosing_node().kind(),
+                JsSyntaxKind::JS_CATCH_CLAUSE | JsSyntaxKind::JS_FINALLY_CLAUSE
+            ) =>
+        {
+            following
+        }
+        _ => return CommentPlacement::Default(comment),
+    };
+
+    // Move comments coming before the `{` inside of the block
+    //
+    // ```javascript
+    // try /* test */ {
+    // }
+    // ```
+    if let Some(block) = JsBlockStatement::cast_ref(following) {
+        return place_block_statement_comment(block, comment);
+    }
+
+    CommentPlacement::Default(comment)
+}
+
+fn handle_for_comment(comment: DecoratedComment<JsLanguage>) -> CommentPlacement<JsLanguage> {
+    let enclosing = comment.enclosing_node();
+
+    let is_for_in_or_of = matches!(
+        enclosing.kind(),
+        JsSyntaxKind::JS_FOR_OF_STATEMENT | JsSyntaxKind::JS_FOR_IN_STATEMENT
+    );
+
+    if !is_for_in_or_of && !matches!(enclosing.kind(), JsSyntaxKind::JS_FOR_STATEMENT) {
+        return CommentPlacement::Default(comment);
+    }
+
+    if comment.text_position().is_own_line() && is_for_in_or_of {
+        CommentPlacement::leading(enclosing.clone(), comment)
+    }
+    // Don't attach comments to empty statement
+    // ```javascript
+    // for /* comment */ (;;);
+    // for (;;a++) /* comment */;
+    // ```
+    else if comment.following_node().map_or(false, |following| {
+        JsEmptyStatement::can_cast(following.kind())
+    }) {
+        if let Some(preceding) = comment.preceding_node() {
+            CommentPlacement::trailing(preceding.clone(), comment)
+        } else {
+            CommentPlacement::dangling(comment.enclosing_node().clone(), comment)
+        }
+    } else {
+        CommentPlacement::Default(comment)
+    }
+}
+
+fn handle_variable_declarator_comment(
+    comment: DecoratedComment<JsLanguage>,
+) -> CommentPlacement<JsLanguage> {
+    let following = match comment.following_node() {
+        Some(following) => following,
+        None => return CommentPlacement::Default(comment),
+    };
+
+    fn is_complex_value(value: &JsSyntaxNode) -> bool {
         matches!(
-            kind,
-            JsSyntaxKind::R_BRACK
-                | JsSyntaxKind::R_CURLY
-                | JsSyntaxKind::R_PAREN
-                | JsSyntaxKind::COMMA
-                | JsSyntaxKind::SEMICOLON
-                | JsSyntaxKind::DOT
-                | JsSyntaxKind::EOF
+            value.kind(),
+            JsSyntaxKind::JS_OBJECT_EXPRESSION
+                | JsSyntaxKind::JS_ARRAY_EXPRESSION
+                | JsSyntaxKind::JS_TEMPLATE
+                | JsSyntaxKind::TS_OBJECT_TYPE
+                | JsSyntaxKind::TS_UNION_TYPE
         )
     }
+
+    let enclosing = comment.enclosing_node();
+    match enclosing.kind() {
+        JsSyntaxKind::JS_ASSIGNMENT_EXPRESSION | JsSyntaxKind::TS_TYPE_ALIAS_DECLARATION => {
+            // Makes all comments preceding objects/arrays/templates or block comments leading comments of these nodes.
+            // ```javascript
+            // let a = // comment
+            // { };
+            // ```
+            if is_complex_value(following) || !comment.kind().is_line() {
+                return CommentPlacement::leading(following.clone(), comment);
+            }
+        }
+        JsSyntaxKind::JS_VARIABLE_DECLARATOR => {
+            let variable_declarator = JsVariableDeclarator::unwrap_cast(enclosing.clone());
+
+            match variable_declarator.initializer() {
+                // ```javascript
+                // let obj2 // Comment
+                // = {
+                //   key: 'val'
+                // }
+                // ```
+                Some(initializer) if initializer.syntax() == following => {
+                    if let Ok(expression) = initializer.expression() {
+                        return CommentPlacement::leading(expression.into_syntax(), comment);
+                    }
+                }
+                _ => {
+                    // fall through
+                }
+            }
+        }
+        JsSyntaxKind::JS_INITIALIZER_CLAUSE => {
+            if let Some(variable_declarator) =
+                enclosing.parent().and_then(JsVariableDeclarator::cast)
+            {
+                // Keep trailing comments with the id for variable declarators. Necessary because the value is wrapped
+                // inside of an initializer clause.
+                // ```javascript
+                // let a = // comment
+                //      b;
+                // ```
+                if !is_complex_value(following)
+                    && !JsCommentStyle::is_suppression(comment.piece().text())
+                    && comment.kind().is_line()
+                    && comment.preceding_node().is_none()
+                {
+                    if let Ok(id) = variable_declarator.id() {
+                        return CommentPlacement::trailing(id.into_syntax(), comment);
+                    }
+                }
+            }
+        }
+        _ => {
+            // fall through
+        }
+    }
+
+    CommentPlacement::Default(comment)
+}
+
+fn handle_parameter_comment(comment: DecoratedComment<JsLanguage>) -> CommentPlacement<JsLanguage> {
+    // Make all own line comments leading comments of the parameter
+    // ```javascript
+    // function a(
+    //   b
+    //   // comment
+    //   = c
+    // )
+    // ```
+    match comment.enclosing_node().kind() {
+        JsSyntaxKind::JS_FORMAL_PARAMETER if comment.text_position().is_own_line() => {
+            return CommentPlacement::leading(comment.enclosing_node().clone(), comment)
+        }
+        JsSyntaxKind::JS_INITIALIZER_CLAUSE => {
+            if let Some(parameter) = comment
+                .enclosing_node()
+                .parent()
+                .and_then(JsFormalParameter::cast)
+            {
+                // Keep end of line comments after the `=` trailing comments of the id
+                // ```javascript
+                // function a(
+                //   b = // test
+                //     c
+                // )
+                // ```
+                if comment.text_position().is_end_of_line() && comment.preceding_node().is_none() {
+                    if let Ok(binding) = parameter.binding() {
+                        return CommentPlacement::trailing(binding.into_syntax(), comment);
+                    }
+                } else if comment.text_position().is_own_line() {
+                    return CommentPlacement::leading(parameter.into_syntax(), comment);
+                }
+            }
+        }
+        _ => {
+            // fall through
+        }
+    }
+
+    CommentPlacement::Default(comment)
+}
+
+/// Format comments preceding the type parameter name in mapped types on the line above.
+///
+/// This is achieved by making them dangling comments of the mapped type.
+///
+/// ```javascript
+/// type A = {
+///   /* comment */
+///   [a in A]: string;
+/// }
+/// ```
+fn handle_mapped_type_comment(
+    comment: DecoratedComment<JsLanguage>,
+) -> CommentPlacement<JsLanguage> {
+    if let (JsSyntaxKind::TS_MAPPED_TYPE, Some(following)) =
+        (comment.enclosing_node().kind(), comment.following_node())
+    {
+        if following.kind() == JsSyntaxKind::TS_TYPE_PARAMETER_NAME {
+            return CommentPlacement::dangling(comment.enclosing_node().clone(), comment);
+        }
+    }
+
+    CommentPlacement::Default(comment)
+}
+
+fn handle_union_type_comment(
+    comment: DecoratedComment<JsLanguage>,
+) -> CommentPlacement<JsLanguage> {
+    match (comment.enclosing_node().kind(), comment.preceding_node()) {
+        (JsSyntaxKind::TS_UNION_TYPE, Some(preceding)) => {
+            CommentPlacement::trailing(preceding.clone(), comment)
+        }
+        _ => CommentPlacement::Default(comment),
+    }
+}
+
+fn handle_import_export_specifier_comment(
+    comment: DecoratedComment<JsLanguage>,
+) -> CommentPlacement<JsLanguage> {
+    let enclosing_node = comment.enclosing_node();
+
+    match enclosing_node.kind() {
+        // Make end of line or own line comments in the middle of an import specifier leading comments of that specifier
+        // ```javascript
+        // import { a //comment1
+        // //comment2
+        // //comment3
+        // as b} from "";
+        // ```
+        JsSyntaxKind::JS_NAMED_IMPORT_SPECIFIER
+        | JsSyntaxKind::JS_EXPORT_NAMED_SPECIFIER
+        | JsSyntaxKind::JS_EXPORT_NAMED_SHORTHAND_SPECIFIER
+        | JsSyntaxKind::JS_EXPORT_NAMED_FROM_SPECIFIER => {
+            CommentPlacement::leading(enclosing_node.clone(), comment)
+        }
+        // Make end of line or own line comments in the middle of an import assertion a leading comment of the assertion
+        JsSyntaxKind::JS_IMPORT_ASSERTION_ENTRY => {
+            CommentPlacement::leading(enclosing_node.clone(), comment)
+        }
+
+        JsSyntaxKind::JS_EXPORT_AS_CLAUSE => {
+            if let Some(parent) = enclosing_node.parent() {
+                CommentPlacement::leading(parent, comment)
+            } else {
+                CommentPlacement::Default(comment)
+            }
+        }
+
+        _ => CommentPlacement::Default(comment),
+    }
+
+    // if (
+    //     enclosingNode?.type === "ImportSpecifier" ||
+    //     enclosingNode?.type === "ExportSpecifier"
+    //   ) {
+    //     addLeadingComment(enclosingNode, comment);
+    //     return true;
+    //   }
+    //
+    //   const isImportDeclaration =
+    //     precedingNode?.type === "ImportSpecifier" &&
+    //     enclosingNode?.type === "ImportDeclaration";
+    //   const isExportDeclaration =
+    //     precedingNode?.type === "ExportSpecifier" &&
+    //     enclosingNode?.type === "ExportNamedDeclaration";
+    //   if (
+    //     (isImportDeclaration || isExportDeclaration) &&
+    //     hasNewline(text, locEnd(comment))
+    //   ) {
+    //     addTrailingComment(precedingNode, comment);
+    //     return true;
+    //   }
+    //   return false;
+}
+
+fn place_leading_statement_comment(
+    statement: JsAnyStatement,
+    comment: DecoratedComment<JsLanguage>,
+) -> CommentPlacement<JsLanguage> {
+    match statement {
+        JsAnyStatement::JsBlockStatement(block) => place_block_statement_comment(block, comment),
+        statement => CommentPlacement::leading(statement.into_syntax(), comment),
+    }
+}
+
+fn place_block_statement_comment(
+    block_statement: JsBlockStatement,
+    comment: DecoratedComment<JsLanguage>,
+) -> CommentPlacement<JsLanguage> {
+    let first_non_empty = block_statement
+        .statements()
+        .iter()
+        .find(|statement| !matches!(statement, JsAnyStatement::JsEmptyStatement(_)));
+
+    match first_non_empty {
+        None => CommentPlacement::dangling(block_statement.into_syntax(), comment),
+        Some(statement) => CommentPlacement::leading(statement.into_syntax(), comment),
+    }
+}
+
+/// Returns `true` if `comment` is a [Closure type comment](https://github.com/google/closure-compiler/wiki/Types-in-the-Closure-Type-System)
+/// or [TypeScript type comment](https://www.typescriptlang.org/docs/handbook/jsdoc-supported-types.html#type)
+pub(crate) fn is_type_comment(comment: &SyntaxTriviaPieceComments<JsLanguage>) -> bool {
+    let text = comment.text();
+
+    // Must be a `/**` comment
+    if !text.starts_with("/**") {
+        return false;
+    }
+
+    text.trim_start_matches("/**")
+        .trim_end_matches("*/")
+        .split_whitespace()
+        .any(|word| match word.strip_prefix("@type") {
+            Some(after) => after.is_empty() || after.starts_with('{'),
+            None => false,
+        })
 }
diff --git a/crates/rome_js_formatter/src/context.rs b/crates/rome_js_formatter/src/context.rs
index b627f8938b8..53655f227d9 100644
--- a/crates/rome_js_formatter/src/context.rs
+++ b/crates/rome_js_formatter/src/context.rs
@@ -1,8 +1,7 @@
-use crate::comments::{FormatJsLeadingComment, JsCommentStyle};
+use crate::comments::{FormatJsLeadingComment, JsCommentStyle, JsComments};
 use rome_formatter::printer::PrinterOptions;
 use rome_formatter::{
-    Comments, CstFormatContext, FormatContext, FormatOptions, IndentStyle, LineWidth,
-    TransformSourceMap,
+    CstFormatContext, FormatContext, FormatOptions, IndentStyle, LineWidth, TransformSourceMap,
 };
 use rome_js_syntax::{JsLanguage, SourceType};
 use std::fmt;
@@ -15,13 +14,13 @@ pub struct JsFormatContext {
     options: JsFormatOptions,
 
     /// The comments of the nodes and tokens in the program.
-    comments: Rc<Comments<JsLanguage>>,
+    comments: Rc<JsComments>,
 
     source_map: Option<TransformSourceMap>,
 }
 
 impl JsFormatContext {
-    pub fn new(options: JsFormatOptions, comments: Comments<JsLanguage>) -> Self {
+    pub fn new(options: JsFormatOptions, comments: JsComments) -> Self {
         Self {
             options,
             comments: Rc::new(comments),
@@ -65,13 +64,9 @@ impl FormatContext for JsFormatContext {
 impl CstFormatContext for JsFormatContext {
     type Language = JsLanguage;
     type Style = JsCommentStyle;
-    type LeadingCommentRule = FormatJsLeadingComment;
+    type CommentRule = FormatJsLeadingComment;
 
-    fn comment_style(&self) -> Self::Style {
-        JsCommentStyle
-    }
-
-    fn comments(&self) -> &Comments<JsLanguage> {
+    fn comments(&self) -> &JsComments {
         &self.comments
     }
 }
diff --git a/crates/rome_js_formatter/src/generated.rs b/crates/rome_js_formatter/src/generated.rs
index 46293030ee2..d6423adec24 100644
--- a/crates/rome_js_formatter/src/generated.rs
+++ b/crates/rome_js_formatter/src/generated.rs
@@ -1,6 +1,8 @@
 //! Generated file, do not edit by hand, see `xtask/codegen`
 
-use crate::{AsFormat, FormatNodeRule, IntoFormat, JsFormatContext, JsFormatter};
+use crate::{
+    AsFormat, FormatNodeRule, FormatUnknownNodeRule, IntoFormat, JsFormatContext, JsFormatter,
+};
 use rome_formatter::{FormatOwnedWithRule, FormatRefWithRule, FormatResult, FormatRule};
 impl FormatRule<rome_js_syntax::JsScript> for crate::js::auxiliary::script::FormatJsScript {
     type Context = JsFormatContext;
@@ -10284,7 +10286,7 @@ impl FormatRule<rome_js_syntax::JsUnknown> for crate::js::unknown::unknown::Form
     type Context = JsFormatContext;
     #[inline(always)]
     fn fmt(&self, node: &rome_js_syntax::JsUnknown, f: &mut JsFormatter) -> FormatResult<()> {
-        FormatNodeRule::<rome_js_syntax::JsUnknown>::fmt(self, node, f)
+        FormatUnknownNodeRule::<rome_js_syntax::JsUnknown>::fmt(self, node, f)
     }
 }
 impl<'a> AsFormat<'a> for rome_js_syntax::JsUnknown {
@@ -10322,7 +10324,7 @@ impl FormatRule<rome_js_syntax::JsUnknownStatement>
         node: &rome_js_syntax::JsUnknownStatement,
         f: &mut JsFormatter,
     ) -> FormatResult<()> {
-        FormatNodeRule::<rome_js_syntax::JsUnknownStatement>::fmt(self, node, f)
+        FormatUnknownNodeRule::<rome_js_syntax::JsUnknownStatement>::fmt(self, node, f)
     }
 }
 impl<'a> AsFormat<'a> for rome_js_syntax::JsUnknownStatement {
@@ -10360,7 +10362,7 @@ impl FormatRule<rome_js_syntax::JsUnknownExpression>
         node: &rome_js_syntax::JsUnknownExpression,
         f: &mut JsFormatter,
     ) -> FormatResult<()> {
-        FormatNodeRule::<rome_js_syntax::JsUnknownExpression>::fmt(self, node, f)
+        FormatUnknownNodeRule::<rome_js_syntax::JsUnknownExpression>::fmt(self, node, f)
     }
 }
 impl<'a> AsFormat<'a> for rome_js_syntax::JsUnknownExpression {
@@ -10394,7 +10396,7 @@ impl FormatRule<rome_js_syntax::JsUnknownMember>
     type Context = JsFormatContext;
     #[inline(always)]
     fn fmt(&self, node: &rome_js_syntax::JsUnknownMember, f: &mut JsFormatter) -> FormatResult<()> {
-        FormatNodeRule::<rome_js_syntax::JsUnknownMember>::fmt(self, node, f)
+        FormatUnknownNodeRule::<rome_js_syntax::JsUnknownMember>::fmt(self, node, f)
     }
 }
 impl<'a> AsFormat<'a> for rome_js_syntax::JsUnknownMember {
@@ -10432,7 +10434,7 @@ impl FormatRule<rome_js_syntax::JsUnknownBinding>
         node: &rome_js_syntax::JsUnknownBinding,
         f: &mut JsFormatter,
     ) -> FormatResult<()> {
-        FormatNodeRule::<rome_js_syntax::JsUnknownBinding>::fmt(self, node, f)
+        FormatUnknownNodeRule::<rome_js_syntax::JsUnknownBinding>::fmt(self, node, f)
     }
 }
 impl<'a> AsFormat<'a> for rome_js_syntax::JsUnknownBinding {
@@ -10470,7 +10472,7 @@ impl FormatRule<rome_js_syntax::JsUnknownAssignment>
         node: &rome_js_syntax::JsUnknownAssignment,
         f: &mut JsFormatter,
     ) -> FormatResult<()> {
-        FormatNodeRule::<rome_js_syntax::JsUnknownAssignment>::fmt(self, node, f)
+        FormatUnknownNodeRule::<rome_js_syntax::JsUnknownAssignment>::fmt(self, node, f)
     }
 }
 impl<'a> AsFormat<'a> for rome_js_syntax::JsUnknownAssignment {
@@ -10508,7 +10510,7 @@ impl FormatRule<rome_js_syntax::JsUnknownParameter>
         node: &rome_js_syntax::JsUnknownParameter,
         f: &mut JsFormatter,
     ) -> FormatResult<()> {
-        FormatNodeRule::<rome_js_syntax::JsUnknownParameter>::fmt(self, node, f)
+        FormatUnknownNodeRule::<rome_js_syntax::JsUnknownParameter>::fmt(self, node, f)
     }
 }
 impl<'a> AsFormat<'a> for rome_js_syntax::JsUnknownParameter {
@@ -10546,7 +10548,7 @@ impl FormatRule<rome_js_syntax::JsUnknownImportAssertionEntry>
         node: &rome_js_syntax::JsUnknownImportAssertionEntry,
         f: &mut JsFormatter,
     ) -> FormatResult<()> {
-        FormatNodeRule::<rome_js_syntax::JsUnknownImportAssertionEntry>::fmt(self, node, f)
+        FormatUnknownNodeRule::<rome_js_syntax::JsUnknownImportAssertionEntry>::fmt(self, node, f)
     }
 }
 impl<'a> AsFormat<'a> for rome_js_syntax::JsUnknownImportAssertionEntry {
@@ -10578,7 +10580,7 @@ impl FormatRule<rome_js_syntax::JsUnknownNamedImportSpecifier>
         node: &rome_js_syntax::JsUnknownNamedImportSpecifier,
         f: &mut JsFormatter,
     ) -> FormatResult<()> {
-        FormatNodeRule::<rome_js_syntax::JsUnknownNamedImportSpecifier>::fmt(self, node, f)
+        FormatUnknownNodeRule::<rome_js_syntax::JsUnknownNamedImportSpecifier>::fmt(self, node, f)
     }
 }
 impl<'a> AsFormat<'a> for rome_js_syntax::JsUnknownNamedImportSpecifier {
diff --git a/crates/rome_js_formatter/src/lib.rs b/crates/rome_js_formatter/src/lib.rs
index a4e823daa53..340c46180d2 100644
--- a/crates/rome_js_formatter/src/lib.rs
+++ b/crates/rome_js_formatter/src/lib.rs
@@ -261,7 +261,7 @@ mod syntax_rewriter;
 
 use rome_formatter::prelude::*;
 use rome_formatter::{
-    write, Comments, CstFormatContext, Format, FormatLanguage, TransformSourceMap,
+    comments::Comments, write, CstFormatContext, Format, FormatLanguage, TransformSourceMap,
 };
 use rome_formatter::{Buffer, FormatOwnedWithRule, FormatRefWithRule, Formatted, Printed};
 use rome_js_syntax::{
@@ -271,11 +271,11 @@ use rome_rowan::SyntaxResult;
 use rome_rowan::TextRange;
 use rome_rowan::{AstNode, SyntaxNode};
 
-use crate::builders::{format_parenthesize, format_suppressed_node};
 use crate::comments::JsCommentStyle;
 use crate::context::{JsFormatContext, JsFormatOptions};
 use crate::cst::FormatJsSyntaxNode;
 use crate::syntax_rewriter::transform;
+use rome_formatter::trivia::format_skipped_token_trivia;
 use std::iter::FusedIterator;
 use std::marker::PhantomData;
 
@@ -424,18 +424,25 @@ where
     N: AstNode<Language = JsLanguage>,
 {
     fn fmt(&self, node: &N, f: &mut JsFormatter) -> FormatResult<()> {
-        let syntax = node.syntax();
+        if self.is_suppressed(node, f) {
+            return write!(f, [format_suppressed_node(node.syntax())]);
+        }
+
+        self.fmt_leading_comments(node, f)?;
+        self.fmt_node(node, f)?;
+        self.fmt_dangling_comments(node, f)?;
+        self.fmt_trailing_comments(node, f)
+    }
 
-        if f.context().comments().is_suppressed(syntax) {
-            write!(f, [format_suppressed_node(syntax)])
-        } else if self.needs_parentheses(node) {
+    fn fmt_node(&self, node: &N, f: &mut JsFormatter) -> FormatResult<()> {
+        if self.needs_parentheses(node) {
             write!(
                 f,
-                [format_parenthesize(
-                    node.syntax().first_token().as_ref(),
-                    &format_once(|f| self.fmt_fields(node, f)),
-                    node.syntax().last_token().as_ref(),
-                )]
+                [
+                    text("("),
+                    format_once(|f| self.fmt_fields(node, f)),
+                    text(")"),
+                ]
             )
         } else {
             self.fmt_fields(node, f)
@@ -450,6 +457,33 @@ where
         let _ = item;
         false
     }
+
+    fn is_suppressed(&self, node: &N, f: &JsFormatter) -> bool {
+        f.context().comments().is_suppressed(node.syntax())
+    }
+
+    fn fmt_leading_comments(&self, node: &N, f: &mut JsFormatter) -> FormatResult<()> {
+        format_leading_comments(node.syntax()).fmt(f)
+    }
+
+    fn fmt_dangling_comments(&self, node: &N, f: &mut JsFormatter) -> FormatResult<()> {
+        format_dangling_comments(node.syntax())
+            .with_soft_block_indent()
+            .fmt(f)
+    }
+
+    fn fmt_trailing_comments(&self, node: &N, f: &mut JsFormatter) -> FormatResult<()> {
+        format_trailing_comments(node.syntax()).fmt(f)
+    }
+}
+
+pub trait FormatUnknownNodeRule<N>
+where
+    N: AstNode<Language = JsLanguage>,
+{
+    fn fmt(&self, node: &N, f: &mut JsFormatter) -> FormatResult<()> {
+        format_unknown_node(node.syntax()).fmt(f)
+    }
 }
 
 /// Format implementation specific to JavaScript tokens.
@@ -464,9 +498,8 @@ impl FormatRule<JsSyntaxToken> for FormatJsSyntaxToken {
         write!(
             f,
             [
-                format_leading_trivia(token),
+                format_skipped_token_trivia(token),
                 format_trimmed_token(token),
-                format_trailing_trivia(token),
             ]
         )
     }
@@ -503,10 +536,6 @@ impl FormatLanguage for JsFormatLanguage {
     type CommentStyle = JsCommentStyle;
     type FormatRule = FormatJsSyntaxNode;
 
-    fn comment_style(&self) -> Self::CommentStyle {
-        JsCommentStyle
-    }
-
     fn transform(
         &self,
         root: &SyntaxNode<Self::SyntaxLanguage>,
@@ -746,6 +775,42 @@ function() {
         assert_eq!(result.range(), Some(TextRange::new(range_start, range_end)));
     }
 
+    #[test]
+    fn test_range_formatting_middle_of_token() {
+        let input = r#"/* */ function Foo(){
+/**/
+}
+"#;
+
+        let range = TextRange::new(TextSize::from(16), TextSize::from(28));
+
+        debug_assert_eq!(
+            &input[range],
+            r#"oo(){
+/**/
+}"#
+        );
+
+        let tree = parse_script(input, 0);
+        let result = format_range(
+            JsFormatOptions::new(SourceType::js_script()).with_indent_style(IndentStyle::Space(4)),
+            &tree.syntax(),
+            range,
+        )
+        .expect("Range formatting failed");
+
+        assert_eq!(
+            result.as_code(),
+            r#"/* */ function Foo() {
+    /**/
+}"#
+        );
+        assert_eq!(
+            result.range(),
+            Some(TextRange::new(TextSize::from(0), TextSize::from(28)))
+        )
+    }
+
     #[ignore]
     #[test]
     // use this test check if your snippet prints as you wish, without using a snapshot
diff --git a/crates/rome_js_formatter/src/prelude.rs b/crates/rome_js_formatter/src/prelude.rs
index 7198ad90739..77801975f6c 100644
--- a/crates/rome_js_formatter/src/prelude.rs
+++ b/crates/rome_js_formatter/src/prelude.rs
@@ -2,17 +2,12 @@
 //! when implementing the [crate::FormatNodeRule] trait.
 
 pub(crate) use crate::{
-    AsFormat as _, FormatNodeRule, FormattedIterExt, JsFormatContext, JsFormatter,
+    builders::format_or_verbatim, comments::JsComments, AsFormat as _, FormatNodeRule,
+    FormattedIterExt, JsFormatContext, JsFormatter,
 };
 pub use rome_formatter::prelude::*;
 pub use rome_rowan::{AstNode as _, AstNodeList as _, AstSeparatedList as _};
 
-pub use crate::builders::{
-    format_delimited, format_inserted, format_inserted_close_paren, format_inserted_open_paren,
-    format_or_verbatim, format_parenthesize, format_suppressed_node, format_unknown_node,
-    format_verbatim_node,
-};
-
 pub use crate::separated::{
     FormatAstSeparatedListExtension, FormatSeparatedOptions, TrailingSeparator,
 };
diff --git a/crates/rome_js_formatter/src/separated.rs b/crates/rome_js_formatter/src/separated.rs
index f0f207c0271..d6584a3a2d6 100644
--- a/crates/rome_js_formatter/src/separated.rs
+++ b/crates/rome_js_formatter/src/separated.rs
@@ -1,7 +1,7 @@
 use crate::prelude::*;
 use crate::AsFormat;
 use rome_formatter::{write, GroupId};
-use rome_js_syntax::{JsLanguage, JsSyntaxKind};
+use rome_js_syntax::JsLanguage;
 use rome_rowan::{
     AstNode, AstSeparatedElement, AstSeparatedList, AstSeparatedListElementsIterator, Language,
 };
@@ -13,7 +13,7 @@ pub struct FormatSeparatedElement<L: Language, N> {
     element: AstSeparatedElement<L, N>,
     is_last: bool,
     /// The separator to write if the element has no separator yet.
-    separator: JsSyntaxKind,
+    separator: &'static str,
     options: FormatSeparatedOptions,
 }
 
@@ -63,12 +63,12 @@ where
                 TrailingSeparator::Allowed => {
                     write!(
                         f,
-                        [if_group_breaks(&format_inserted(self.separator))
+                        [if_group_breaks(&text(self.separator))
                             .with_group_id(self.options.group_id)]
                     )?;
                 }
                 TrailingSeparator::Mandatory => {
-                    format_inserted(self.separator).fmt(f)?;
+                    text(self.separator).fmt(f)?;
                 }
                 TrailingSeparator::Omit | TrailingSeparator::Disallowed => { /* no op */ }
             }
@@ -90,7 +90,7 @@ where
 {
     next: Option<AstSeparatedElement<Language, Node>>,
     inner: I,
-    separator: JsSyntaxKind,
+    separator: &'static str,
     options: FormatSeparatedOptions,
 }
 
@@ -98,7 +98,7 @@ impl<I, L, Node> FormatSeparatedIter<I, L, Node>
 where
     L: Language,
 {
-    fn new(inner: I, separator: JsSyntaxKind) -> Self {
+    fn new(inner: I, separator: &'static str) -> Self {
         Self {
             inner,
             separator,
@@ -166,7 +166,7 @@ pub trait FormatAstSeparatedListExtension: AstSeparatedList<Language = JsLanguag
     /// if the outer group breaks.
     fn format_separated(
         &self,
-        separator: JsSyntaxKind,
+        separator: &'static str,
     ) -> FormatSeparatedIter<
         AstSeparatedListElementsIterator<JsLanguage, Self::Node>,
         JsLanguage,
diff --git a/crates/rome_js_formatter/src/syntax_rewriter.rs b/crates/rome_js_formatter/src/syntax_rewriter.rs
index 66217b26b73..4fdd26c3c23 100644
--- a/crates/rome_js_formatter/src/syntax_rewriter.rs
+++ b/crates/rome_js_formatter/src/syntax_rewriter.rs
@@ -1,3 +1,4 @@
+use crate::comments::is_type_comment;
 use crate::parentheses::JsAnyParenthesized;
 use crate::TextRange;
 use rome_formatter::{TransformSourceMap, TransformSourceMapBuilder};
@@ -7,8 +8,7 @@ use rome_js_syntax::{
 };
 use rome_rowan::syntax::SyntaxTrivia;
 use rome_rowan::{
-    AstNode, SyntaxKind, SyntaxRewriter, SyntaxToken, SyntaxTriviaPiece, SyntaxTriviaPieceComments,
-    VisitNodeSignal,
+    AstNode, SyntaxKind, SyntaxRewriter, SyntaxToken, SyntaxTriviaPiece, VisitNodeSignal,
 };
 use std::iter::FusedIterator;
 
@@ -174,10 +174,26 @@ impl JsFormatSyntaxRewriter {
                 self.source_map
                     .add_deleted_range(l_paren.text_trimmed_range());
 
-                let l_paren_trivia = chain_pieces(
-                    l_paren.leading_trivia().pieces(),
-                    l_paren.trailing_trivia().pieces(),
-                );
+                let mut l_paren_trailing = l_paren.trailing_trivia().pieces().peekable();
+
+                // Skip over leading whitespace
+                while let Some(piece) = l_paren_trailing.peek() {
+                    if piece.is_whitespace() {
+                        self.source_map
+                            .add_deleted_range(TextRange::at(inner_offset, piece.text_len()));
+                        inner_offset += piece.text_len();
+                        l_paren_trailing.next();
+                    } else {
+                        break;
+                    }
+                }
+
+                let l_paren_trailing_non_whitespace_trivia = l_paren_trailing
+                    .peek()
+                    .map_or(false, |piece| piece.is_skipped() || piece.is_comments());
+
+                let l_paren_trivia =
+                    chain_pieces(l_paren.leading_trivia().pieces(), l_paren_trailing);
 
                 let mut leading_trivia = first_token.leading_trivia().pieces().peekable();
                 let mut first_new_line = None;
@@ -185,8 +201,9 @@ impl JsFormatSyntaxRewriter {
                 // The leading whitespace before the opening parens replaces the whitespace before the node.
                 while let Some(trivia) = leading_trivia.peek() {
                     if trivia.is_newline() && first_new_line.is_none() {
-                        inner_offset += trivia.text_len();
+                        let trivia_len = trivia.text_len();
                         first_new_line = Some((inner_offset, leading_trivia.next().unwrap()));
+                        inner_offset += trivia_len;
                     } else if trivia.is_whitespace() || trivia.is_newline() {
                         let trivia_len = trivia.text_len();
                         self.source_map
@@ -199,7 +216,10 @@ impl JsFormatSyntaxRewriter {
                 }
 
                 // Remove all leading new lines directly in front of the token but keep the leading new-line if it precedes a skipped token trivia or a comment.
-                if leading_trivia.peek().is_none() && first_new_line.is_some() {
+                if !l_paren_trailing_non_whitespace_trivia
+                    && leading_trivia.peek().is_none()
+                    && first_new_line.is_some()
+                {
                     let (inner_offset, new_line) = first_new_line.take().unwrap();
 
                     self.source_map
@@ -380,25 +400,6 @@ fn has_type_cast_comment_or_skipped(trivia: &SyntaxTrivia<JsLanguage>) -> bool {
     })
 }
 
-/// Returns `true` if `comment` is a [Closure type comment](https://github.com/google/closure-compiler/wiki/Types-in-the-Closure-Type-System)
-/// or [TypeScript type comment](https://www.typescriptlang.org/docs/handbook/jsdoc-supported-types.html#type)
-fn is_type_comment(comment: &SyntaxTriviaPieceComments<JsLanguage>) -> bool {
-    let text = comment.text();
-
-    // Must be a `/**` comment
-    if !text.starts_with("/**") {
-        return false;
-    }
-
-    text.trim_start_matches("/**")
-        .trim_end_matches("*/")
-        .split_whitespace()
-        .any(|word| match word.strip_prefix("@type") {
-            Some(after) => after.is_empty() || after.starts_with('{'),
-            None => false,
-        })
-}
-
 fn chain_pieces<F, S>(first: F, second: S) -> ChainTriviaPiecesIterator<F, S>
 where
     F: Iterator<Item = SyntaxTriviaPiece<JsLanguage>>,
@@ -499,14 +500,14 @@ where
 #[cfg(test)]
 mod tests {
     use super::JsFormatSyntaxRewriter;
-    use crate::{format_node, JsFormatOptions};
+    use crate::{format_node, JsFormatOptions, TextRange};
     use rome_diagnostics::file::FileId;
     use rome_formatter::{SourceMarker, TransformSourceMap};
     use rome_js_parser::parse_module;
     use rome_js_syntax::{
         JsArrayExpression, JsBinaryExpression, JsExpressionStatement, JsIdentifierExpression,
         JsLogicalExpression, JsSequenceExpression, JsStringLiteralExpression, JsSyntaxNode,
-        SourceType,
+        JsUnaryExpression, SourceType,
     };
     use rome_rowan::{AstNode, SyntaxRewriter, TextSize};
 
@@ -760,6 +761,79 @@ mod tests {
         );
     }
 
+    #[test]
+    fn parentheses() {
+        let (transformed, source_map) = source_map_test(
+            r#"!(
+  /* foo */
+  x
+);
+!(
+  x // foo
+);
+!(
+  /* foo */
+  x + y
+);
+!(
+  x + y
+  /* foo */
+);
+!(
+  x + y // foo
+);"#,
+        );
+
+        let unary_expressions = transformed
+            .descendants()
+            .filter_map(JsUnaryExpression::cast)
+            .collect::<Vec<_>>();
+        assert_eq!(unary_expressions.len(), 5);
+
+        assert_eq!(
+            source_map.trimmed_source_text(unary_expressions[0].syntax()),
+            r#"!(
+  /* foo */
+  x
+)"#
+        );
+
+        assert_eq!(
+            source_map.source_range(unary_expressions[1].syntax().text_range()),
+            TextRange::new(TextSize::from(21), TextSize::from(36))
+        );
+
+        assert_eq!(
+            source_map.trimmed_source_text(unary_expressions[1].syntax()),
+            r#"!(
+  x // foo
+)"#
+        );
+
+        assert_eq!(
+            source_map.trimmed_source_text(unary_expressions[2].syntax()),
+            r#"!(
+  /* foo */
+  x + y
+)"#
+        );
+
+        assert_eq!(
+            source_map.trimmed_source_text(unary_expressions[3].syntax()),
+            r#"!(
+  x + y
+  /* foo */
+)"#
+        );
+
+        assert_eq!(
+            source_map.trimmed_source_text(unary_expressions[4].syntax()),
+            r#"!(
+  x + y // foo
+)"#
+        );
+    }
+
     fn source_map_test(input: &str) -> (JsSyntaxNode, TransformSourceMap) {
         let tree = parse_module(input, FileId::zero()).syntax();
 

From 7581c1d120d27e3b4fdedb1336bb17909e2bbb8b Mon Sep 17 00:00:00 2001
From: Micha Reiser <micha@rome.tools>
Date: Fri, 16 Sep 2022 15:34:31 +0200
Subject: [PATCH 13/15] Documentation

---
 crates/rome_js_formatter/src/comments.rs | 23 -----------------------
 crates/rome_js_formatter/src/lib.rs      | 19 +++++++++++++++++++
 2 files changed, 19 insertions(+), 23 deletions(-)

diff --git a/crates/rome_js_formatter/src/comments.rs b/crates/rome_js_formatter/src/comments.rs
index 1424e0325fd..e7b0c435700 100644
--- a/crates/rome_js_formatter/src/comments.rs
+++ b/crates/rome_js_formatter/src/comments.rs
@@ -1090,29 +1090,6 @@ fn handle_import_export_specifier_comment(
 
         _ => CommentPlacement::Default(comment),
     }
-
-    // if (
-    //     enclosingNode?.type === "ImportSpecifier" ||
-    //     enclosingNode?.type === "ExportSpecifier"
-    //   ) {
-    //     addLeadingComment(enclosingNode, comment);
-    //     return true;
-    //   }
-    //
-    //   const isImportDeclaration =
-    //     precedingNode?.type === "ImportSpecifier" &&
-    //     enclosingNode?.type === "ImportDeclaration";
-    //   const isExportDeclaration =
-    //     precedingNode?.type === "ExportSpecifier" &&
-    //     enclosingNode?.type === "ExportNamedDeclaration";
-    //   if (
-    //     (isImportDeclaration || isExportDeclaration) &&
-    //     hasNewline(text, locEnd(comment))
-    //   ) {
-    //     addTrailingComment(precedingNode, comment);
-    //     return true;
-    //   }
-    //   return false;
 }
 
 fn place_leading_statement_comment(
diff --git a/crates/rome_js_formatter/src/lib.rs b/crates/rome_js_formatter/src/lib.rs
index 340c46180d2..cf9e0abd760 100644
--- a/crates/rome_js_formatter/src/lib.rs
+++ b/crates/rome_js_formatter/src/lib.rs
@@ -419,6 +419,7 @@ where
 {
 }
 
+/// Rule for formatting a JavaScript [AstNode].
 pub trait FormatNodeRule<N>
 where
     N: AstNode<Language = JsLanguage>,
@@ -434,6 +435,7 @@ where
         self.fmt_trailing_comments(node, f)
     }
 
+    /// Formats the node without comments. Ignores any suppression comments.
     fn fmt_node(&self, node: &N, f: &mut JsFormatter) -> FormatResult<()> {
         if self.needs_parentheses(node) {
             write!(
@@ -458,25 +460,42 @@ where
         false
     }
 
+    /// Returns `true` if the node has a suppression comment and should use the same formatting as in the source document.
     fn is_suppressed(&self, node: &N, f: &JsFormatter) -> bool {
         f.context().comments().is_suppressed(node.syntax())
     }
 
+    /// Formats the [leading comments](rome_formatter::comments#leading-comments) of the node.
+    ///
+    /// You may want to override this method if you want to manually handle the formatting of comments
+    /// inside of the `fmt_fields` method or customize the formatting of the leading comments.
     fn fmt_leading_comments(&self, node: &N, f: &mut JsFormatter) -> FormatResult<()> {
         format_leading_comments(node.syntax()).fmt(f)
     }
 
+    /// Formats the [dangling comments](rome_formatter::comments#dangling-comments) of the node.
+    ///
+    /// You should override this method if the node handled by this rule can have dangling comments because the
+    /// default implementation formats the dangling comments at the end of the node, which isn't ideal but ensures that
+    /// no comments are dropped.
+    ///
+    /// A node can have dangling comments if all its children are tokens or if all node childrens are optional.
     fn fmt_dangling_comments(&self, node: &N, f: &mut JsFormatter) -> FormatResult<()> {
         format_dangling_comments(node.syntax())
             .with_soft_block_indent()
             .fmt(f)
     }
 
+    /// Formats the [trailing comments](rome_formatter::comments#trailing-comments) of the node.
+    ///
+    /// You may want to override this method if you want to manually handle the formatting of comments
+    /// inside of the `fmt_fields` method or customize the formatting of the trailing comments.
     fn fmt_trailing_comments(&self, node: &N, f: &mut JsFormatter) -> FormatResult<()> {
         format_trailing_comments(node.syntax()).fmt(f)
     }
 }
 
+/// Rule for formatting an unknown node.
 pub trait FormatUnknownNodeRule<N>
 where
     N: AstNode<Language = JsLanguage>,

From 74147a3dd0c10078dae04a6d0286b88fbe164e21 Mon Sep 17 00:00:00 2001
From: Micha Reiser <micha@rome.tools>
Date: Thu, 22 Sep 2022 08:13:32 +0200
Subject: [PATCH 14/15] refactor(rome_js_formatter): Part 7: Use comments API
 in JS node formatters (#3245)

---
 Cargo.lock                                    |   1 +
 crates/rome_formatter/Cargo.toml              |   1 +
 crates/rome_formatter/src/comments.rs         |   6 +-
 crates/rome_formatter/src/comments/builder.rs | 233 +++--
 crates/rome_formatter/src/source_map.rs       |  50 +-
 crates/rome_js_formatter/src/comments.rs      |  20 +-
 .../assignments/array_assignment_pattern.rs   |  28 +-
 .../assignments/object_assignment_pattern.rs  |   9 +
 .../src/js/auxiliary/default_clause.rs        |  11 +-
 .../src/js/auxiliary/function_body.rs         |  33 +-
 .../src/js/auxiliary/module.rs                |  20 +
 .../src/js/auxiliary/script.rs                |  20 +
 .../src/js/bindings/array_binding_pattern.rs  |  28 +-
 .../src/js/bindings/constructor_parameters.rs |   9 +
 .../src/js/bindings/object_binding_pattern.rs |   9 +
 .../src/js/bindings/parameters.rs             |  61 +-
 .../src/js/classes/extends_clause.rs          |  23 +-
 ...tatic_initialization_block_class_member.rs |  28 +-
 .../src/js/declarations/catch_declaration.rs  |  46 +-
 .../src/js/declarations/class_declaration.rs  |   9 +
 .../class_export_default_declaration.rs       |   9 +
 .../js/declarations/function_declaration.rs   |  15 +-
 .../src/js/expressions/array_expression.rs    |  32 +-
 .../expressions/arrow_function_expression.rs  |  50 +-
 .../src/js/expressions/call_arguments.rs      | 136 ++-
 .../src/js/expressions/class_expression.rs    |   9 +
 .../src/js/expressions/new_expression.rs      |   8 +-
 .../src/js/expressions/object_expression.rs   |   9 +
 .../expressions/parenthesized_expression.rs   |   6 +-
 .../src/js/expressions/template_element.rs    |  11 +-
 .../src/js/expressions/unary_expression.rs    |  10 +-
 .../src/js/lists/array_element_list.rs        |  54 +-
 .../src/js/lists/call_argument_list.rs        |   4 +-
 .../lists/export_named_from_specifier_list.rs |   4 +-
 .../js/lists/export_named_specifier_list.rs   |   4 +-
 .../js/lists/import_assertion_entry_list.rs   |   4 +-
 .../js/lists/named_import_specifier_list.rs   |   4 +-
 ...object_assignment_pattern_property_list.rs |   6 +-
 .../object_binding_pattern_property_list.rs   |   6 +-
 .../src/js/lists/object_member_list.rs        |   7 +-
 .../src/js/lists/parameter_list.rs            |  19 +-
 .../src/js/lists/template_element_list.rs     |  16 +-
 .../src/js/lists/variable_declarator_list.rs  |   4 +-
 .../src/js/module/export_named_clause.rs      |  38 +-
 .../src/js/module/export_named_from_clause.rs |  30 +-
 .../src/js/module/import_assertion.rs         |  36 +-
 .../src/js/module/import_assertion_entry.rs   |  31 +-
 .../src/js/module/named_import_specifiers.rs  |  31 +-
 .../src/js/statements/block_statement.rs      |  84 +-
 .../src/js/statements/break_statement.rs      |   2 +-
 .../src/js/statements/continue_statement.rs   |   2 +-
 .../src/js/statements/do_while_statement.rs   |   5 +-
 .../src/js/statements/expression_statement.rs |  21 +-
 .../src/js/statements/for_statement.rs        |  22 +-
 .../src/js/statements/if_statement.rs         |  38 +-
 .../src/js/statements/labeled_statement.rs    |   7 +-
 .../src/js/statements/return_statement.rs     | 146 ++-
 .../src/js/statements/switch_statement.rs     |   9 +-
 .../src/js/statements/throw_statement.rs      |  27 +-
 .../js/statements/try_finally_statement.rs    |   2 +-
 .../src/js/statements/while_statement.rs      |   5 +-
 .../src/js/unknown/unknown.rs                 |  10 +-
 .../src/js/unknown/unknown_assignment.rs      |  18 +-
 .../src/js/unknown/unknown_binding.rs         |  10 +-
 .../src/js/unknown/unknown_expression.rs      |  18 +-
 .../unknown/unknown_import_assertion_entry.rs |  14 +-
 .../src/js/unknown/unknown_member.rs          |  10 +-
 .../unknown/unknown_named_import_specifier.rs |  14 +-
 .../src/js/unknown/unknown_parameter.rs       |  14 +-
 .../src/js/unknown/unknown_statement.rs       |  14 +-
 .../attribute/expression_attribute_value.rs   |  13 +-
 .../src/jsx/attribute/spread_attribute.rs     |  24 +-
 .../src/jsx/auxiliary/expression_child.rs     |  94 +-
 .../src/jsx/auxiliary/spread_child.rs         |  31 +-
 .../src/jsx/expressions/tag_expression.rs     |  30 +-
 .../src/jsx/lists/child_list.rs               | 111 ++-
 .../src/jsx/tag/closing_fragment.rs           |  32 +
 .../rome_js_formatter/src/jsx/tag/element.rs  |  69 +-
 .../rome_js_formatter/src/jsx/tag/fragment.rs |  29 +
 .../src/jsx/tag/opening_element.rs            |  14 +-
 .../src/jsx/tag/opening_fragment.rs           |  32 +-
 .../src/jsx/tag/self_closing_element.rs       |  41 +
 crates/rome_js_formatter/src/lib.rs           |  35 +-
 .../rome_js_formatter/src/syntax_rewriter.rs  | 101 ++-
 .../assignments/type_assertion_assignment.rs  |   5 +-
 .../auxiliary/call_signature_type_member.rs   |   5 +-
 .../construct_signature_type_member.rs        |   5 +-
 .../src/ts/auxiliary/module_block.rs          |  21 +-
 .../src/ts/bindings/type_parameters.rs        |  18 +-
 .../src/ts/classes/extends_clause.rs          |  11 +-
 .../src/ts/declarations/enum_declaration.rs   |   5 +-
 .../ts/declarations/interface_declaration.rs  |  92 +-
 .../src/ts/expressions/type_arguments.rs      |  27 +-
 .../expressions/type_assertion_expression.rs  |   5 +-
 .../src/ts/lists/enum_member_list.rs          |   4 +-
 .../src/ts/lists/tuple_type_element_list.rs   |   4 +-
 .../src/ts/lists/type_argument_list.rs        |   4 +-
 .../src/ts/lists/type_list.rs                 |   4 +-
 .../src/ts/lists/type_member_list.rs          |   9 +-
 .../src/ts/lists/type_parameter_list.rs       |   4 +-
 .../src/ts/lists/union_type_variant_list.rs   | 189 +++-
 .../src/ts/types/mapped_type.rs               |  79 +-
 .../src/ts/types/object_type.rs               |   5 +
 .../src/ts/types/tuple_type.rs                |  24 +-
 .../src/ts/types/union_type.rs                |  32 +-
 crates/rome_js_formatter/src/utils/array.rs   |   6 +-
 .../src/utils/assignment_like.rs              |  66 +-
 .../src/utils/binary_like_expression.rs       |  42 +-
 .../src/utils/conditional.rs                  |  42 +-
 .../src/utils/format_class.rs                 |  97 +-
 crates/rome_js_formatter/src/utils/jsx.rs     |  89 +-
 .../src/utils/member_chain/chain_member.rs    |  81 +-
 .../src/utils/member_chain/groups.rs          |  71 +-
 .../src/utils/member_chain/mod.rs             |  79 +-
 crates/rome_js_formatter/src/utils/mod.rs     |  49 +-
 crates/rome_js_formatter/src/utils/object.rs  |   9 +-
 .../src/utils/object_like.rs                  |  28 +-
 .../src/utils/object_pattern_like.rs          |  26 +-
 .../tests/specs/js/module/arrow/call.js.snap  |   7 +-
 .../specs/js/module/assignment/assignment.js  |   2 +-
 .../js/module/assignment/assignment.js.snap   |   6 +-
 .../binding/array-binding-holes.js.snap       |   2 +-
 .../specs/js/module/call_expression.js.snap   |  15 +-
 .../js/module/class/class_comments.js.snap    |   1 +
 .../tests/specs/js/module/comments.js.snap    |  25 +-
 .../declarations/variable_declaration.js.snap | 125 ++-
 .../expression/binary_expression.js.snap      |   2 +-
 .../expression/logical_expression.js.snap     |   7 +-
 .../static_member_expression.js.snap          |   3 +-
 .../module/function/function_comments.js.snap |   1 +
 .../specs/js/module/import/bare_import.js     |  17 +-
 .../js/module/import/bare_import.js.snap      |  26 +-
 .../module/number/number_with_space.js.snap   |   3 +-
 .../specs/js/module/statement/if_else.js      |   7 +-
 .../specs/js/module/statement/if_else.js.snap |  15 +-
 .../specs/js/module/statement/switch.js.snap  |   3 +-
 .../tests/specs/js/module/suppression.js.snap |   6 +-
 .../specs/js/module/template/template.js.snap |  12 +-
 .../tests/specs/jsx/attributes.jsx.snap       |   9 +-
 .../tests/specs/jsx/element.jsx.snap          |   3 +-
 ...mbers-negative-comment-after-minus.js.snap | 121 ---
 .../js/arrays/numbers-with-holes.js.snap      |  19 +-
 .../numbers-with-tricky-comments.js.snap      |  10 +-
 .../js/assignment-comments/call.js.snap       |  47 -
 .../js/assignment-comments/call2.js.snap      |  34 -
 .../js/assignment-comments/function.js.snap   | 200 -----
 .../js/assignment-comments/identifier.js.snap |  52 --
 .../js/assignment-comments/number.js.snap     | 125 ---
 .../js/assignment-comments/string.js.snap     | 202 -----
 .../prettier/js/assignment/lone-arg.js.snap   |  18 +-
 .../prettier/js/babel-plugins/bigint.js.snap  | 293 ------
 .../babel-plugins/export-default-from.js.snap |   6 +-
 .../js/babel-plugins/optional-chaining.js     |   1 -
 .../babel-plugins/optional-chaining.js.snap   | 159 ----
 .../pipeline-operator-hack.js.snap            |   7 +-
 .../private-fields-in-in.js.snap              | 141 ---
 .../prettier/js/break-calls/react.js.snap     |  48 +-
 .../js/class-comment/superclass.js.snap       | 161 ----
 .../specs/prettier/js/classes/method.js.snap  |  52 --
 .../closure-compiler-type-cast.js.snap        |  64 +-
 .../comment-in-the-middle.js.snap             |  57 ++
 .../comment-placement.js.snap                 |  70 --
 .../issue-4124.js.snap                        |  71 --
 .../issue-8045.js.snap                        | 114 ---
 .../object-with-comment.js.snap               |  58 --
 .../binary-expressions-block-comments.js.snap | 183 ----
 .../js/comments/binary-expressions.js.snap    | 274 ------
 .../break-continue-statements.js.snap         |  30 +-
 .../prettier/js/comments/call_comment.js.snap |  73 --
 .../prettier/js/comments/dangling.js.snap     |  61 --
 .../prettier/js/comments/dangling_for.js.snap |  39 -
 .../js/comments/dynamic_imports.js.snap       |  10 +-
 .../js/comments/export-and-import.js.snap     |  93 --
 .../specs/prettier/js/comments/export.js.snap |  34 +-
 .../js/comments/function-declaration.js.snap  | 215 -----
 .../tests/specs/prettier/js/comments/if.js    |   6 +-
 .../specs/prettier/js/comments/if.js.snap     | 227 -----
 .../specs/prettier/js/comments/issues.js.snap | 187 ----
 .../specs/prettier/js/comments/jsx.js.snap    | 148 +--
 .../multi-comments-on-same-line.js.snap       |  11 +-
 .../comments/preserve-new-line-last.js.snap   |  80 --
 .../js/comments/return-statement.js.snap      |  15 +-
 .../js/comments/single-star-jsdoc.js.snap     |  95 --
 .../specs/prettier/js/comments/switch.js.snap | 120 ---
 .../comments/tagged-template-literal.js.snap  |  10 +-
 .../js/comments/template-literal.js.snap      |  64 --
 .../js/comments/trailing-jsdocs.js.snap       | 101 ---
 .../specs/prettier/js/comments/try.js.snap    |  72 --
 .../js/comments/variable_declarator.js.snap   | 207 -----
 .../specs/prettier/js/comments/while.js.snap  |  88 --
 .../prettier/js/conditional/comments.js.snap  | 336 -------
 .../prettier/js/decorators/classes.js.snap    |   6 +-
 .../prettier/js/decorators/comments.js.snap   |   2 +
 .../prettier/js/decorators/multiple.js.snap   |   8 +-
 .../js/destructuring-ignore/ignore.js.snap    | 126 ---
 .../js/first-argument-expansion/test.js.snap  |  29 +-
 .../specs/prettier/js/for/comment.js.snap     | 132 ---
 .../for/continue-and-break-comment-1.js.snap  |  84 +-
 .../for/continue-and-break-comment-2.js.snap  | 480 ----------
 ...e-and-break-comment-without-blocks.js.snap | 272 ++----
 .../function_expression.js.snap               | 141 ---
 .../js/if/expr_and_same_line_comments.js.snap | 104 ---
 .../specs/prettier/js/if/if_comments.js.snap  | 191 ----
 .../prettier/js/if/trailing_comment.js.snap   |  65 --
 .../specs/prettier/js/ignore/ignore-2.js.snap |  73 --
 .../specs/prettier/js/ignore/ignore.js.snap   | 149 ----
 .../prettier/js/ignore/issue-10661.js.snap    | 107 ---
 .../prettier/js/ignore/semi/directive.js.snap |  50 --
 .../specs/prettier/js/import/comments.js.snap | 149 ----
 .../specs/prettier/js/label/comment.js.snap   |  53 --
 .../js/last-argument-expansion/arrow.js.snap  |  10 +-
 .../last-argument-expansion/edge_case.js.snap |  89 +-
 .../empty-object.js.snap                      |  83 --
 .../js/line-suffix-boundary/boundary.js.snap  | 107 ---
 .../prettier/js/method-chain/comment.js.snap  | 107 +--
 .../js/method-chain/issue-4125.js.snap        |  44 +-
 .../js/module-blocks/comments.js.snap         |  10 +-
 .../comment-inside.js.snap                    | 111 ++-
 .../object-property-comment/after-key.js.snap |  48 -
 .../js/object-property-ignore/ignore.js.snap  | 134 ---
 .../object-property-ignore/issue-5678.js.snap | 137 ---
 .../js/optional-chaining/comments.js.snap     |  31 +-
 .../js/preserve-line/argument-list.js.snap    |  57 +-
 .../specs/prettier/js/return/comment.js.snap  | 143 ---
 .../specs/prettier/js/switch/comments.js.snap | 159 ----
 .../prettier/js/template/comment.js.snap      |  60 --
 .../prettier/js/ternaries/nested.js.snap      | 226 -----
 .../js/throw_statement/comment.js.snap        |  95 --
 .../trailing_whitespace.js.snap               | 137 ---
 .../tests/specs/prettier/js/try/catch.js.snap |  84 --
 .../tests/specs/prettier/js/try/try.js.snap   |  41 -
 .../js/unary-expression/comments.js.snap      | 840 ------------------
 .../prettier/jsx/fragment/fragment.js.snap    | 202 -----
 .../specs/prettier/jsx/ignore/jsx_ignore.js   |   1 -
 .../prettier/jsx/ignore/jsx_ignore.js.snap    | 193 ----
 .../specs/prettier/jsx/split-attrs/test.js    |   1 -
 .../prettier/jsx/split-attrs/test.js.snap     | 261 ------
 .../prettier/jsx/spread/attribute.js.snap     |  56 +-
 .../tests/specs/prettier/jsx/spread/child.js  |   2 -
 .../specs/prettier/jsx/spread/child.js.snap   |  75 +-
 .../typescript/arrow/comments.ts.snap         |  11 +-
 .../class-comment/class-implements.ts.snap    | 271 ------
 .../typescript/class-comment/declare.ts.snap  |  65 --
 .../class/extends_implements.ts.snap          | 188 ----
 .../typescript/class/generics.ts.snap         |  52 --
 .../comments/after_jsx_generic.ts.snap        |  93 --
 .../typescript/comments/mapped_types.ts.snap  |  60 +-
 .../typescript/comments/method_types.ts.snap  |  39 +-
 .../typescript/comments/methods.ts.snap       | 131 ---
 .../comments/type-parameters.ts.snap          |  56 +-
 .../typescript/comments/union.ts.snap         |  85 --
 .../conditional-types/comments.ts.snap        | 218 -----
 .../types/mappedType/mappedType.ts.snap       |  37 -
 .../custom/typeParameters/variables.ts.snap   |  26 +-
 .../typescript/decorators/decorators.ts.snap  |  56 +-
 .../decorators/inline-decorators.ts.snap      |   8 +-
 .../typescript/error-recovery/generic.ts.snap | 145 +++
 .../typescript/export/comment.ts.snap         |  32 -
 .../typescript/interface2/break.ts.snap       |  55 +-
 .../typescript/interface2/comments.ts.snap    | 128 ---
 .../keyword-types/conditional-types.ts.snap   |  56 --
 ...keyword-types-with-parens-comments.ts.snap | 168 ----
 .../typescript/keywords/keywords.ts.snap      |   6 +-
 .../mapped-type/mapped-type.ts.snap           |  44 -
 .../prettier-ignore/mapped-types.ts.snap      | 116 +--
 .../typescript/typeof-this/decorators.ts.snap |  46 -
 .../typescript/union/inlining.ts.snap         | 134 ---
 .../typescript/union/prettier-ignore.ts.snap  | 103 ---
 .../specs/ts/assignment/assignment.ts.snap    |   2 +-
 .../specs/ts/declaration/interface.ts.snap    |   3 +-
 .../tests/specs/ts/decoartors.ts.snap         |  16 +
 .../tests/specs/ts/suppressions.ts.snap       |   2 +-
 .../tests/specs/ts/type/conditional.ts.snap   |  13 +-
 .../specs/ts/type/intersection_type.ts.snap   |   4 +-
 .../tests/specs/ts/type/union_type.ts.snap    |  26 +-
 275 files changed, 3473 insertions(+), 13616 deletions(-)
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/js/arrays/numbers-negative-comment-after-minus.js.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/js/assignment-comments/call.js.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/js/assignment-comments/call2.js.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/js/assignment-comments/function.js.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/js/assignment-comments/identifier.js.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/js/assignment-comments/number.js.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/js/assignment-comments/string.js.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/js/babel-plugins/bigint.js.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/js/babel-plugins/optional-chaining.js.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/js/babel-plugins/private-fields-in-in.js.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/js/class-comment/superclass.js.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/js/classes/method.js.snap
 create mode 100644 crates/rome_js_formatter/tests/specs/prettier/js/comments-closure-typecast/comment-in-the-middle.js.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/js/comments-closure-typecast/comment-placement.js.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/js/comments-closure-typecast/issue-4124.js.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/js/comments-closure-typecast/issue-8045.js.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/js/comments-closure-typecast/object-with-comment.js.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/js/comments/binary-expressions-block-comments.js.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/js/comments/binary-expressions.js.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/js/comments/call_comment.js.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/js/comments/dangling.js.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/js/comments/dangling_for.js.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/js/comments/export-and-import.js.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/js/comments/function-declaration.js.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/js/comments/if.js.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/js/comments/issues.js.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/js/comments/preserve-new-line-last.js.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/js/comments/single-star-jsdoc.js.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/js/comments/switch.js.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/js/comments/template-literal.js.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/js/comments/trailing-jsdocs.js.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/js/comments/try.js.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/js/comments/variable_declarator.js.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/js/comments/while.js.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/js/conditional/comments.js.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/js/destructuring-ignore/ignore.js.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/js/for/comment.js.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/js/for/continue-and-break-comment-2.js.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/js/function-first-param/function_expression.js.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/js/if/expr_and_same_line_comments.js.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/js/if/if_comments.js.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/js/if/trailing_comment.js.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/js/ignore/ignore-2.js.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/js/ignore/ignore.js.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/js/ignore/issue-10661.js.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/js/ignore/semi/directive.js.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/js/import/comments.js.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/js/label/comment.js.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/js/last-argument-expansion/empty-object.js.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/js/line-suffix-boundary/boundary.js.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/js/object-property-comment/after-key.js.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/js/object-property-ignore/ignore.js.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/js/object-property-ignore/issue-5678.js.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/js/return/comment.js.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/js/switch/comments.js.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/js/template/comment.js.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/js/ternaries/nested.js.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/js/throw_statement/comment.js.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/js/trailing-comma/trailing_whitespace.js.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/js/try/catch.js.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/js/try/try.js.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/js/unary-expression/comments.js.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/jsx/fragment/fragment.js.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/jsx/ignore/jsx_ignore.js.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/jsx/split-attrs/test.js.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/typescript/class-comment/class-implements.ts.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/typescript/class-comment/declare.ts.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/typescript/class/extends_implements.ts.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/typescript/class/generics.ts.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/typescript/comments/after_jsx_generic.ts.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/typescript/comments/methods.ts.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/typescript/comments/union.ts.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/typescript/conditional-types/comments.ts.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/typescript/conformance/types/mappedType/mappedType.ts.snap
 create mode 100644 crates/rome_js_formatter/tests/specs/prettier/typescript/error-recovery/generic.ts.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/typescript/export/comment.ts.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/typescript/interface2/comments.ts.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/typescript/keyword-types/conditional-types.ts.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/typescript/keyword-types/keyword-types-with-parens-comments.ts.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/typescript/mapped-type/mapped-type.ts.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/typescript/typeof-this/decorators.ts.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/typescript/union/inlining.ts.snap
 delete mode 100644 crates/rome_js_formatter/tests/specs/prettier/typescript/union/prettier-ignore.ts.snap

diff --git a/Cargo.lock b/Cargo.lock
index 4ad4eab2e64..54127814bd9 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1587,6 +1587,7 @@ dependencies = [
  "cfg-if",
  "countme",
  "indexmap",
+ "rome_diagnostics",
  "rome_js_parser",
  "rome_js_syntax",
  "rome_rowan",
diff --git a/crates/rome_formatter/Cargo.toml b/crates/rome_formatter/Cargo.toml
index 5c63d0c7b5b..a8f910a590e 100644
--- a/crates/rome_formatter/Cargo.toml
+++ b/crates/rome_formatter/Cargo.toml
@@ -21,6 +21,7 @@ countme = "3.0.1"
 [dev-dependencies]
 rome_js_parser = { path = "../rome_js_parser"}
 rome_js_syntax = { path = "../rome_js_syntax" }
+rome_diagnostics = { path = "../rome_diagnostics" }
 
 [features]
 serde = ["dep:serde", "schemars", "rome_rowan/serde"]
diff --git a/crates/rome_formatter/src/comments.rs b/crates/rome_formatter/src/comments.rs
index 711f9a2f1e6..80debabafe1 100644
--- a/crates/rome_formatter/src/comments.rs
+++ b/crates/rome_formatter/src/comments.rs
@@ -237,7 +237,7 @@ pub struct DecoratedComment<L: Language> {
     enclosing: SyntaxNode<L>,
     preceding: Option<SyntaxNode<L>>,
     following: Option<SyntaxNode<L>>,
-    following_token: SyntaxToken<L>,
+    following_token: Option<SyntaxToken<L>>,
     text_position: CommentTextPosition,
     lines_before: u32,
     lines_after: u32,
@@ -434,8 +434,8 @@ impl<L: Language> DecoratedComment<L> {
     /// ```
     ///
     /// The `following_token` for both comments is `b` because it's the token coming after the comments.
-    pub fn following_token(&self) -> &SyntaxToken<L> {
-        &self.following_token
+    pub fn following_token(&self) -> Option<&SyntaxToken<L>> {
+        self.following_token.as_ref()
     }
 }
 
diff --git a/crates/rome_formatter/src/comments/builder.rs b/crates/rome_formatter/src/comments/builder.rs
index e666f779631..dc197522939 100644
--- a/crates/rome_formatter/src/comments/builder.rs
+++ b/crates/rome_formatter/src/comments/builder.rs
@@ -71,6 +71,22 @@ where
             "Expected all enclosing nodes to have been processed but contains {:#?}",
             self.parents
         );
+
+        // Process any comments attached to the last token.
+        // Important for range formatting where it isn't guaranteed that the
+        // last token is an EOF token.
+        if let Some(last_token) = self.last_token.take() {
+            self.parents.push(root.clone());
+            let (comments_start, lines_before, position, trailing_end) =
+                self.visit_trailing_comments(last_token, None);
+            Self::update_comments(
+                &mut self.pending_comments[comments_start..],
+                position,
+                lines_before,
+                trailing_end,
+            );
+        }
+
         self.flush_comments(None);
 
         self.builder.finish()
@@ -116,65 +132,18 @@ where
     }
 
     fn visit_token(&mut self, token: SyntaxToken<Style::Language>) {
-        let mut comments_start = self.pending_comments.len();
-
-        // The index of the last trailing comment in `pending_comments`.
-        let mut trailing_end: Option<usize> = None;
-
-        // Number of lines before the next comment, token, or skipped token trivia
-        let mut lines_before = 0;
-
-        // Trailing comments are all `SameLine` comments EXCEPT if any is followed by a line break,
-        // a leading comment (that always have line breaks), or there's a line break before the token.
-        let mut position = CommentTextPosition::SameLine;
-
         // Process the trailing trivia of the last token
-        if let Some(last_token) = self.last_token.take() {
-            for piece in last_token.trailing_trivia().pieces() {
-                if piece.is_newline() {
-                    lines_before += 1;
-                    // All comments following from here are own line comments
-                    position = CommentTextPosition::OwnLine;
-
-                    if trailing_end.is_none() {
-                        trailing_end = Some(self.pending_comments.len());
-                    }
-                } else if let Some(comment) = piece.as_comments() {
-                    self.queue_comment(DecoratedComment {
-                        enclosing: self.enclosing_node().clone(),
-                        preceding: self.preceding_node.clone(),
-                        following: None,
-                        following_token: token.clone(),
-                        lines_before,
-                        lines_after: 0, // Will be initialized after
-                        text_position: position,
-                        kind: Style::get_comment_kind(&comment),
-                        comment,
-                    });
-
-                    lines_before = 0;
-                }
-
-                if let Some(parens_source_range) = self
-                    .parentheses
-                    .r_paren_source_range(piece.text_range().end())
-                {
-                    self.flush_before_r_paren_comments(
-                        parens_source_range,
-                        &last_token,
-                        position,
-                        lines_before,
-                        comments_start,
-                        trailing_end,
-                    );
-
-                    lines_before = 0;
-                    position = CommentTextPosition::SameLine;
-                    comments_start = 0;
-                    trailing_end = None;
-                }
-            }
-        }
+        let (comments_start, mut lines_before, mut position, mut trailing_end) =
+            if let Some(last_token) = self.last_token.take() {
+                self.visit_trailing_comments(last_token, Some(&token))
+            } else {
+                (
+                    self.pending_comments.len(),
+                    0,
+                    CommentTextPosition::SameLine,
+                    None,
+                )
+            };
 
         // Process the leading trivia of the current token. the trailing trivia is handled as part of the next token
         for leading in token.leading_trivia().pieces() {
@@ -198,7 +167,7 @@ where
                     enclosing: self.enclosing_node().clone(),
                     preceding: self.preceding_node.clone(),
                     following: None,
-                    following_token: token.clone(),
+                    following_token: Some(token.clone()),
                     lines_before,
                     lines_after: 0,
                     text_position: position,
@@ -210,26 +179,14 @@ where
             }
         }
 
-        let trailing_end = trailing_end.unwrap_or(self.pending_comments.len());
-
         self.last_token = Some(token);
 
-        let mut comments = self.pending_comments[comments_start..]
-            .iter_mut()
-            .enumerate()
-            .peekable();
-
-        // Update the lines after of all comments as well as the positioning of end of line comments.
-        while let Some((index, comment)) = comments.next() {
-            // Update the position of all trailing comments to be end of line as we've seen a line break since.
-            if index < trailing_end && position.is_own_line() {
-                comment.text_position = CommentTextPosition::EndOfLine;
-            }
-
-            comment.lines_after = comments
-                .peek()
-                .map_or(lines_before, |(_, next)| next.lines_before);
-        }
+        Self::update_comments(
+            &mut self.pending_comments[comments_start..],
+            position,
+            lines_before,
+            trailing_end,
+        );
 
         // Set following node to `None` because it now becomes the enclosing node.
         if let Some(following_node) = self.following_node() {
@@ -265,6 +222,28 @@ where
         self.pending_comments.push(comment);
     }
 
+    fn update_comments(
+        comments: &mut [DecoratedComment<Style::Language>],
+        position: CommentTextPosition,
+        lines_before: u32,
+        trailing_end: Option<usize>,
+    ) {
+        let trailing_end = trailing_end.unwrap_or(comments.len());
+        let mut comments = comments.iter_mut().enumerate().peekable();
+
+        // Update the lines after of all comments as well as the positioning of end of line comments.
+        while let Some((index, comment)) = comments.next() {
+            // Update the position of all trailing comments to be end of line as we've seen a line break since.
+            if index < trailing_end && position.is_own_line() {
+                comment.text_position = CommentTextPosition::EndOfLine;
+            }
+
+            comment.lines_after = comments
+                .peek()
+                .map_or(lines_before, |(_, next)| next.lines_before);
+        }
+    }
+
     fn flush_comments(&mut self, following: Option<&SyntaxNode<Style::Language>>) {
         for mut comment in self.pending_comments.drain(..) {
             comment.following = following.cloned();
@@ -274,6 +253,72 @@ where
         }
     }
 
+    fn visit_trailing_comments(
+        &mut self,
+        token: SyntaxToken<Style::Language>,
+        following_token: Option<&SyntaxToken<Style::Language>>,
+    ) -> (usize, u32, CommentTextPosition, Option<usize>) {
+        let mut comments_start = 0;
+
+        // The index of the last trailing comment in `pending_comments`.
+        let mut trailing_end: Option<usize> = None;
+
+        // Number of lines before the next comment, token, or skipped token trivia
+        let mut lines_before = 0;
+
+        // Trailing comments are all `SameLine` comments EXCEPT if any is followed by a line break,
+        // a leading comment (that always have line breaks), or there's a line break before the token.
+        let mut position = CommentTextPosition::SameLine;
+
+        // Process the trailing trivia of the last token
+        for piece in token.trailing_trivia().pieces() {
+            if piece.is_newline() {
+                lines_before += 1;
+                // All comments following from here are own line comments
+                position = CommentTextPosition::OwnLine;
+
+                if trailing_end.is_none() {
+                    trailing_end = Some(self.pending_comments.len());
+                }
+            } else if let Some(comment) = piece.as_comments() {
+                self.queue_comment(DecoratedComment {
+                    enclosing: self.enclosing_node().clone(),
+                    preceding: self.preceding_node.clone(),
+                    following: None,
+                    following_token: following_token.cloned(),
+                    lines_before,
+                    lines_after: 0, // Will be initialized after
+                    text_position: position,
+                    kind: Style::get_comment_kind(&comment),
+                    comment,
+                });
+
+                lines_before = 0;
+            }
+
+            if let Some(parens_source_range) = self
+                .parentheses
+                .r_paren_source_range(piece.text_range().end())
+            {
+                self.flush_before_r_paren_comments(
+                    parens_source_range,
+                    &token,
+                    position,
+                    lines_before,
+                    comments_start,
+                    trailing_end,
+                );
+
+                lines_before = 0;
+                position = CommentTextPosition::SameLine;
+                comments_start = 0;
+                trailing_end = None;
+            }
+        }
+
+        (comments_start, lines_before, position, trailing_end)
+    }
+
     /// Processes comments appearing right before a `)` of a parenthesized expressions.
     #[cold]
     fn flush_before_r_paren_comments(
@@ -287,19 +332,16 @@ where
     ) {
         let enclosing = self.enclosing_node().clone();
 
-        let trailing_end = trailing_end.unwrap_or(self.pending_comments.len());
-        let mut comments = self.pending_comments[start..]
-            .iter_mut()
-            .enumerate()
-            .peekable();
+        let comments = &mut self.pending_comments[start..];
+        let trailing_end = trailing_end.unwrap_or(comments.len());
+
+        let mut comments = comments.iter_mut().enumerate().peekable();
 
         let parenthesized_node = self
             .parentheses
             .outer_most_parenthesized_node(last_token, parens_source_range);
 
-        // SAFETY: Safe, because the above loop at least returns the parent of the token. If this isn't the case,
-        // then it's likely that the source map is corrupted.
-        let preceding = parenthesized_node.expect("Last token to have a parent node.");
+        let preceding = parenthesized_node;
 
         // Using the `enclosing` as default but it's mainly to satisfy Rust. The only case where it is used
         // is if someone formats a Parenthesized expression as the root. Something we explicitly disallow
@@ -538,9 +580,9 @@ impl<'a> SourceParentheses<'a> {
         &self,
         token: &SyntaxToken<L>,
         parentheses_source_range: TextRange,
-    ) -> Option<SyntaxNode<L>> {
+    ) -> SyntaxNode<L> {
         match self {
-            SourceParentheses::Empty => token.parent(),
+            SourceParentheses::Empty => token.parent().unwrap(),
             SourceParentheses::SourceMap { map, .. } => {
                 debug_assert_eq!(&map.text()[parentheses_source_range], ")");
 
@@ -567,7 +609,11 @@ impl<'a> SourceParentheses<'a> {
 
                     if let Some(start) = start_offset {
                         TextRange::new(start, r_paren_source_end).contains_range(source_range)
-                    } else if source_range.end() == r_paren_source_end {
+                    }
+                    // Greater than to guarantee that we always return at least one node AND
+                    // handle the case where a node is wrapped in multiple parentheses.
+                    // Take the first node that fully encloses the parentheses
+                    else if source_range.end() >= r_paren_source_end {
                         start_offset = Some(source_range.start());
                         true
                     } else {
@@ -575,7 +621,11 @@ impl<'a> SourceParentheses<'a> {
                     }
                 });
 
-                ancestors.last()
+                // SAFETY:
+                // * The builder starts with a node which guarantees that every token has a parent node.
+                // * The above `take_while` guarantees to return `true` for the parent of the token.
+                // Thus, there's always at least one node
+                ancestors.last().unwrap()
             }
         }
     }
@@ -589,6 +639,7 @@ mod tests {
         DecoratedComment, SourceComment,
     };
     use crate::{TextSize, TransformSourceMap, TransformSourceMapBuilder};
+    use rome_diagnostics::file::FileId;
     use rome_js_parser::parse_module;
     use rome_js_syntax::{
         JsIdentifierExpression, JsLanguage, JsParameters, JsParenthesizedExpression,
@@ -800,7 +851,7 @@ b;"#;
 
         let source_map = source_map_builder.finish();
 
-        let root = parse_module(source, 0).syntax();
+        let root = parse_module(source, FileId::zero()).syntax();
 
         // A lot of code that simply removes the parenthesized expression and moves the parens
         // trivia to the identifiers leading / trailing trivia.
@@ -961,7 +1012,7 @@ b;"#;
         Vec<DecoratedComment<JsLanguage>>,
         CommentsMap<SyntaxElementKey, SourceComment<JsLanguage>>,
     ) {
-        let tree = parse_module(source, 0);
+        let tree = parse_module(source, FileId::zero());
 
         let style = TestCommentStyle::default();
         let builder = CommentsBuilderVisitor::new(&style, source_map);
diff --git a/crates/rome_formatter/src/source_map.rs b/crates/rome_formatter/src/source_map.rs
index 786f606ec0f..a1ccd11c6ac 100644
--- a/crates/rome_formatter/src/source_map.rs
+++ b/crates/rome_formatter/src/source_map.rs
@@ -88,6 +88,26 @@ impl TransformSourceMap {
         self.trimmed_source_range_from_transformed_range(node.text_trimmed_range())
     }
 
+    fn resolve_trimmed_range(&self, mut source_range: TextRange) -> TextRange {
+        let start_mapping = self.mapped_node_ranges.get(&source_range.start());
+        if let Some(mapping) = start_mapping {
+            // If the queried node fully encloses the original range of the node, then extend the range
+            if source_range.contains_range(mapping.original_range) {
+                source_range = TextRange::new(mapping.extended_range.start(), source_range.end());
+            }
+        }
+
+        let end_mapping = self.mapped_node_ranges.get(&source_range.end());
+        if let Some(mapping) = end_mapping {
+            // If the queried node fully encloses the original range of the node, then extend the range
+            if source_range.contains_range(mapping.original_range) {
+                source_range = TextRange::new(source_range.start(), mapping.extended_range.end());
+            }
+        }
+
+        source_range
+    }
+
     fn trimmed_source_range_from_transformed_range(
         &self,
         transformed_range: TextRange,
@@ -97,34 +117,14 @@ impl TransformSourceMap {
         let mut mapped_range = source_range;
 
         loop {
-            let mut widened = false;
-
-            let start_mapping = self.mapped_node_ranges.get(&mapped_range.start());
-            if let Some(mapping) = start_mapping {
-                // If the queried node fully encloses the original range of the node, then extend the range
-                if mapped_range.contains_range(mapping.original_range) {
-                    mapped_range =
-                        TextRange::new(mapping.extended_range.start(), mapped_range.end());
-                    widened = true;
-                }
-            }
+            let resolved = self.resolve_trimmed_range(mapped_range);
 
-            let end_mapping = self.mapped_node_ranges.get(&mapped_range.end());
-            if let Some(mapping) = end_mapping {
-                // If the queried node fully encloses the original range of the node, then extend the range
-                if mapped_range.contains_range(mapping.original_range) {
-                    mapped_range =
-                        TextRange::new(mapped_range.start(), mapping.extended_range.end());
-                    widened = true;
-                }
-            }
-
-            if !widened {
-                break;
+            if resolved == mapped_range {
+                break resolved;
+            } else {
+                mapped_range = resolved;
             }
         }
-
-        mapped_range
     }
 
     /// Returns the source text of the trimmed range of `node`.
diff --git a/crates/rome_js_formatter/src/comments.rs b/crates/rome_js_formatter/src/comments.rs
index e7b0c435700..ae42caa24b9 100644
--- a/crates/rome_js_formatter/src/comments.rs
+++ b/crates/rome_js_formatter/src/comments.rs
@@ -218,7 +218,9 @@ fn handle_typecast_comment(comment: DecoratedComment<JsLanguage>) -> CommentPlac
 fn handle_after_arrow_param_comment(
     comment: DecoratedComment<JsLanguage>,
 ) -> CommentPlacement<JsLanguage> {
-    let is_next_arrow = comment.following_token().kind() == JsSyntaxKind::FAT_ARROW;
+    let is_next_arrow = comment
+        .following_token()
+        .map_or(false, |token| token.kind() == JsSyntaxKind::FAT_ARROW);
 
     // Makes comments after the `(` and `=>` dangling comments
     // ```javascript
@@ -379,7 +381,11 @@ fn handle_class_comment(comment: DecoratedComment<JsLanguage>) -> CommentPlaceme
         // ```javascript
         // class Test { /* comment */ }
         // ```
-        if comment.following_token().kind() == JsSyntaxKind::R_CURLY && first_member.is_none() {
+        if comment
+            .following_token()
+            .map_or(false, |token| token.kind() == JsSyntaxKind::R_CURLY)
+            && first_member.is_none()
+        {
             return CommentPlacement::dangling(comment.enclosing_node().clone(), comment);
         } else {
             return CommentPlacement::Default(comment);
@@ -674,7 +680,10 @@ fn handle_if_statement_comment(
 
             if let Some(preceding) = comment.preceding_node() {
                 // Test if this is a comment right before the condition's `)`
-                if comment.following_token().kind() == JsSyntaxKind::R_PAREN {
+                if comment
+                    .following_token()
+                    .map_or(false, |token| token.kind() == JsSyntaxKind::R_PAREN)
+                {
                     return CommentPlacement::trailing(preceding.clone(), comment);
                 }
 
@@ -763,7 +772,10 @@ fn handle_while_comment(comment: DecoratedComment<JsLanguage>) -> CommentPlaceme
 
     if let Some(preceding) = comment.preceding_node() {
         // Test if this is a comment right before the condition's `)`
-        if comment.following_token().kind() == JsSyntaxKind::R_PAREN {
+        if comment
+            .following_token()
+            .map_or(false, |token| token.kind() == JsSyntaxKind::R_PAREN)
+        {
             return CommentPlacement::trailing(preceding.clone(), comment);
         }
     }
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 a27dcda70ab..144ac9ffaf0 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
@@ -15,18 +15,32 @@ impl FormatNodeRule<JsArrayAssignmentPattern> for FormatJsArrayAssignmentPattern
             r_brack_token,
         } = node.as_fields();
 
-        write!(
-            f,
-            [
-                format_delimited(&l_brack_token?, &elements.format(), &r_brack_token?,)
-                    .soft_block_indent()
-            ]
-        )
+        write!(f, [l_brack_token.format(),])?;
+
+        if elements.is_empty() {
+            write!(
+                f,
+                [format_dangling_comments(node.syntax()).with_block_indent()]
+            )?;
+        } else {
+            write!(f, [group(&soft_block_indent(&elements.format()))])?;
+        }
+
+        write!(f, [r_brack_token.format()])
     }
 
     fn needs_parentheses(&self, item: &JsArrayAssignmentPattern) -> bool {
         item.needs_parentheses()
     }
+
+    fn fmt_dangling_comments(
+        &self,
+        _: &JsArrayAssignmentPattern,
+        _: &mut JsFormatter,
+    ) -> FormatResult<()> {
+        // Handled inside of `fmt_fields`
+        Ok(())
+    }
 }
 
 impl NeedsParentheses for JsArrayAssignmentPattern {
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 f9b39bafa77..098d408836a 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
@@ -19,6 +19,15 @@ impl FormatNodeRule<JsObjectAssignmentPattern> for FormatJsObjectAssignmentPatte
     fn needs_parentheses(&self, item: &JsObjectAssignmentPattern) -> bool {
         item.needs_parentheses()
     }
+
+    fn fmt_dangling_comments(
+        &self,
+        _: &JsObjectAssignmentPattern,
+        _: &mut JsFormatter,
+    ) -> FormatResult<()> {
+        // Handled inside of `JsObjectPatternLike`
+        Ok(())
+    }
 }
 
 impl NeedsParentheses for JsObjectAssignmentPattern {
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 0c114725144..4081c6a73ec 100644
--- a/crates/rome_js_formatter/src/js/auxiliary/default_clause.rs
+++ b/crates/rome_js_formatter/src/js/auxiliary/default_clause.rs
@@ -20,7 +20,11 @@ impl FormatNodeRule<JsDefaultClause> for FormatJsDefaultClause {
             Some(JsAnyStatement::JsBlockStatement(_))
         );
 
-        write!(f, [default_token.format(), colon_token.format(), space()])?;
+        write!(f, [default_token.format(), colon_token.format()])?;
+
+        if f.comments().has_dangling_comments(node.syntax()) {
+            write!(f, [space(), format_dangling_comments(node.syntax())])?;
+        }
 
         if consequent.is_empty() {
             write!(f, [hard_line_break()])
@@ -37,4 +41,9 @@ impl FormatNodeRule<JsDefaultClause> for FormatJsDefaultClause {
             )
         }
     }
+
+    fn fmt_dangling_comments(&self, _: &JsDefaultClause, _: &mut JsFormatter) -> FormatResult<()> {
+        // Handled inside of `fmt_fields`
+        Ok(())
+    }
 }
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 a4196e33908..9615c612a25 100644
--- a/crates/rome_js_formatter/src/js/auxiliary/function_body.rs
+++ b/crates/rome_js_formatter/src/js/auxiliary/function_body.rs
@@ -16,14 +16,31 @@ impl FormatNodeRule<JsFunctionBody> for FormatJsFunctionBody {
             r_curly_token,
         } = node.as_fields();
 
-        write!(
-            f,
-            [format_delimited(
-                &l_curly_token?,
-                &format_args![directives.format(), statements.format()],
-                &r_curly_token?,
+        let r_curly_token = r_curly_token?;
+
+        if statements.is_empty() && directives.is_empty() {
+            write!(
+                f,
+                [
+                    l_curly_token.format(),
+                    format_dangling_comments(node.syntax()).with_block_indent(),
+                    r_curly_token.format()
+                ]
+            )
+        } else {
+            write!(
+                f,
+                [
+                    l_curly_token.format(),
+                    block_indent(&format_args![directives.format(), statements.format()]),
+                    r_curly_token.format(),
+                ]
             )
-            .block_indent()]
-        )
+        }
+    }
+
+    fn fmt_dangling_comments(&self, _: &JsFunctionBody, _: &mut JsFormatter) -> FormatResult<()> {
+        // Formatted as part of `fmt_fields`
+        Ok(())
     }
 }
diff --git a/crates/rome_js_formatter/src/js/auxiliary/module.rs b/crates/rome_js_formatter/src/js/auxiliary/module.rs
index 3dd6a9a578d..ded5df5f008 100644
--- a/crates/rome_js_formatter/src/js/auxiliary/module.rs
+++ b/crates/rome_js_formatter/src/js/auxiliary/module.rs
@@ -22,6 +22,7 @@ impl FormatNodeRule<JsModule> for FormatJsModule {
             f,
             [
                 FormatInterpreterToken::new(interpreter_token.as_ref()),
+                format_leading_comments(node.syntax()),
                 directives.format()
             ]
         ]?;
@@ -30,9 +31,28 @@ impl FormatNodeRule<JsModule> for FormatJsModule {
             f,
             [
                 items.format(),
+                format_trailing_comments(node.syntax()),
                 format_removed(&eof_token?),
                 hard_line_break()
             ]
         )
     }
+
+    fn fmt_leading_comments(&self, _: &JsModule, _: &mut JsFormatter) -> FormatResult<()> {
+        // Formatted as part of `fmt_fields`
+        Ok(())
+    }
+
+    fn fmt_dangling_comments(&self, module: &JsModule, f: &mut JsFormatter) -> FormatResult<()> {
+        debug_assert!(
+            !f.comments().has_dangling_comments(module.syntax()),
+            "Module should never have dangling comments."
+        );
+        Ok(())
+    }
+
+    fn fmt_trailing_comments(&self, _: &JsModule, _: &mut JsFormatter) -> FormatResult<()> {
+        // Formatted as part of `fmt_fields`
+        Ok(())
+    }
 }
diff --git a/crates/rome_js_formatter/src/js/auxiliary/script.rs b/crates/rome_js_formatter/src/js/auxiliary/script.rs
index 2202c15083e..c166f441720 100644
--- a/crates/rome_js_formatter/src/js/auxiliary/script.rs
+++ b/crates/rome_js_formatter/src/js/auxiliary/script.rs
@@ -21,6 +21,7 @@ impl FormatNodeRule<JsScript> for FormatJsScript {
             f,
             [
                 FormatInterpreterToken::new(interpreter_token.as_ref()),
+                format_leading_comments(node.syntax()),
                 directives.format(),
             ]
         ]?;
@@ -29,9 +30,28 @@ impl FormatNodeRule<JsScript> for FormatJsScript {
             f,
             [
                 statements.format(),
+                format_trailing_comments(node.syntax()),
                 format_removed(&eof_token?),
                 hard_line_break()
             ]
         ]
     }
+
+    fn fmt_leading_comments(&self, _: &JsScript, _: &mut JsFormatter) -> FormatResult<()> {
+        // Formatted as part of `fmt_fields`
+        Ok(())
+    }
+
+    fn fmt_dangling_comments(&self, node: &JsScript, f: &mut JsFormatter) -> FormatResult<()> {
+        debug_assert!(
+            !f.comments().has_dangling_comments(node.syntax()),
+            "Scrip should never have dangling comments."
+        );
+        Ok(())
+    }
+
+    fn fmt_trailing_comments(&self, _: &JsScript, _: &mut JsFormatter) -> FormatResult<()> {
+        // Formatted as part of `fmt_fields`
+        Ok(())
+    }
 }
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 0bed8341c80..b55c334e8df 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
@@ -15,12 +15,26 @@ impl FormatNodeRule<JsArrayBindingPattern> for FormatJsArrayBindingPattern {
             r_brack_token,
         } = node.as_fields();
 
-        write!(
-            f,
-            [
-                format_delimited(&l_brack_token?, &elements.format(), &r_brack_token?,)
-                    .soft_block_indent()
-            ]
-        )
+        write!(f, [l_brack_token.format(),])?;
+
+        if elements.is_empty() {
+            write!(
+                f,
+                [format_dangling_comments(node.syntax()).with_block_indent()]
+            )?;
+        } else {
+            write!(f, [group(&soft_block_indent(&elements.format()))])?;
+        }
+
+        write!(f, [r_brack_token.format()])
+    }
+
+    fn fmt_dangling_comments(
+        &self,
+        _: &JsArrayBindingPattern,
+        _: &mut JsFormatter,
+    ) -> FormatResult<()> {
+        // Handled inside of `fmt_fields`
+        Ok(())
     }
 }
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 99e41411f2c..9d072c86b09 100644
--- a/crates/rome_js_formatter/src/js/bindings/constructor_parameters.rs
+++ b/crates/rome_js_formatter/src/js/bindings/constructor_parameters.rs
@@ -10,4 +10,13 @@ impl FormatNodeRule<JsConstructorParameters> for FormatJsConstructorParameters {
     fn fmt_fields(&self, node: &JsConstructorParameters, f: &mut JsFormatter) -> FormatResult<()> {
         FormatJsAnyParameters::from(node.clone()).fmt(f)
     }
+
+    fn fmt_dangling_comments(
+        &self,
+        _: &JsConstructorParameters,
+        _: &mut JsFormatter,
+    ) -> FormatResult<()> {
+        // Formatted inside of `FormatJsAnyParameters
+        Ok(())
+    }
 }
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 1bb8d5bb2c2..3957a65e051 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
@@ -10,4 +10,13 @@ impl FormatNodeRule<JsObjectBindingPattern> for FormatJsObjectBindingPattern {
     fn fmt_fields(&self, node: &JsObjectBindingPattern, f: &mut JsFormatter) -> FormatResult<()> {
         write!(f, [JsObjectPatternLike::from(node.clone())])
     }
+
+    fn fmt_dangling_comments(
+        &self,
+        _: &JsObjectBindingPattern,
+        _: &mut JsFormatter,
+    ) -> FormatResult<()> {
+        // Handled in `JsObjectPatternLike`
+        Ok(())
+    }
 }
diff --git a/crates/rome_js_formatter/src/js/bindings/parameters.rs b/crates/rome_js_formatter/src/js/bindings/parameters.rs
index 295335d98ab..781d676230f 100644
--- a/crates/rome_js_formatter/src/js/bindings/parameters.rs
+++ b/crates/rome_js_formatter/src/js/bindings/parameters.rs
@@ -1,5 +1,5 @@
 use crate::prelude::*;
-use rome_formatter::write;
+use rome_formatter::{write, CstFormatContext};
 
 use crate::js::expressions::call_arguments::is_test_call_expression;
 use crate::js::lists::parameter_list::{
@@ -19,6 +19,11 @@ impl FormatNodeRule<JsParameters> for FormatJsParameters {
     fn fmt_fields(&self, node: &JsParameters, f: &mut JsFormatter) -> FormatResult<()> {
         FormatJsAnyParameters::from(node.clone()).fmt(f)
     }
+
+    fn fmt_dangling_comments(&self, _: &JsParameters, _: &mut JsFormatter) -> FormatResult<()> {
+        // Formatted inside of `FormatJsAnyParameters
+        Ok(())
+    }
 }
 
 declare_node_union! {
@@ -39,9 +44,12 @@ impl Format<JsFormatContext> for FormatJsAnyParameters {
             Err(_) => false,
         });
 
-        let can_hug = should_hug_function_parameters(self)? && !has_any_decorated_parameter;
+        let can_hug = should_hug_function_parameters(self, f.context().comments())?
+            && !has_any_decorated_parameter;
 
-        let layout = if can_hug || self.is_in_test_call()? {
+        let layout = if list.is_empty() {
+            ParameterLayout::NoParameters
+        } else if can_hug || self.is_in_test_call()? {
             ParameterLayout::Hug
         } else {
             ParameterLayout::Default
@@ -51,6 +59,16 @@ impl Format<JsFormatContext> for FormatJsAnyParameters {
         let r_paren_token = self.r_paren_token()?;
 
         match layout {
+            ParameterLayout::NoParameters => {
+                write!(
+                    f,
+                    [
+                        l_paren_token.format(),
+                        format_dangling_comments(self.syntax()).with_soft_block_indent(),
+                        r_paren_token.format()
+                    ]
+                )
+            }
             ParameterLayout::Hug => {
                 write!(
                     f,
@@ -61,14 +79,19 @@ impl Format<JsFormatContext> for FormatJsAnyParameters {
                     ]
                 )
             }
-            ParameterLayout::Default => format_delimited(
-                &l_paren_token,
-                &FormatJsAnyParameterList::with_layout(&list, ParameterLayout::Default),
-                &r_paren_token,
-            )
-            .soft_block_indent()
-            .ungrouped()
-            .fmt(f),
+            ParameterLayout::Default => {
+                write!(
+                    f,
+                    [
+                        l_paren_token.format(),
+                        soft_block_indent(&FormatJsAnyParameterList::with_layout(
+                            &list,
+                            ParameterLayout::Default
+                        )),
+                        r_paren_token.format()
+                    ]
+                )
+            }
         }
     }
 }
@@ -138,6 +161,11 @@ impl FormatJsAnyParameters {
 
 #[derive(Copy, Debug, Clone, Eq, PartialEq)]
 pub enum ParameterLayout {
+    /// ```javascript
+    /// function test() {}
+    /// ```
+    NoParameters,
+
     /// Enforce that the opening and closing parentheses aren't separated from the first token of the parameter.
     /// For example, to enforce that the `{`  and `}` of an object expression are formatted on the same line
     /// as the `(` and `)` tokens even IF the object expression itself breaks across multiple lines.
@@ -163,7 +191,10 @@ pub enum ParameterLayout {
     Default,
 }
 
-fn should_hug_function_parameters(parameters: &FormatJsAnyParameters) -> FormatResult<bool> {
+fn should_hug_function_parameters(
+    parameters: &FormatJsAnyParameters,
+    comments: &JsComments,
+) -> FormatResult<bool> {
     use rome_js_syntax::{
         JsAnyBinding::*, JsAnyBindingPattern::*, JsAnyExpression::*, JsAnyFormalParameter::*,
         JsAnyParameter::*,
@@ -175,14 +206,10 @@ fn should_hug_function_parameters(parameters: &FormatJsAnyParameters) -> FormatR
         return Ok(false);
     }
 
-    if parameters.r_paren_token()?.has_leading_comments() {
-        return Ok(false);
-    }
-
     // SAFETY: Safe because of the length check above
     let only_parameter = list.first().unwrap()?;
 
-    if only_parameter.syntax().has_comments_direct() {
+    if comments.has_comments(only_parameter.syntax()) {
         return Ok(false);
     }
 
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 64b00a294a9..8cdda609637 100644
--- a/crates/rome_js_formatter/src/js/classes/extends_clause.rs
+++ b/crates/rome_js_formatter/src/js/classes/extends_clause.rs
@@ -1,9 +1,9 @@
 use crate::prelude::*;
 
 use rome_formatter::{format_args, write};
+use rome_js_syntax::JsExtendsClause;
 use rome_js_syntax::JsExtendsClauseFields;
 use rome_js_syntax::JsSyntaxKind::JS_ASSIGNMENT_EXPRESSION;
-use rome_js_syntax::{JsExtendsClause, JsSyntaxKind};
 
 #[derive(Debug, Clone, Default)]
 pub struct FormatJsExtendsClause;
@@ -22,10 +22,11 @@ impl FormatNodeRule<JsExtendsClause> for FormatJsExtendsClause {
             let content =
                 format_with(|f| write!(f, [super_class.format(), type_arguments.format()]));
 
+            let comments = f.comments();
             let has_trailing_comments = if let Some(type_arguments) = &type_arguments {
-                type_arguments.syntax().has_trailing_comments()
+                comments.has_trailing_comments(type_arguments.syntax())
             } else {
-                super_class.syntax().has_trailing_comments()
+                comments.has_trailing_comments(super_class.syntax())
             };
 
             if node
@@ -33,25 +34,17 @@ impl FormatNodeRule<JsExtendsClause> for FormatJsExtendsClause {
                 .grand_parent()
                 .map_or(false, |p| p.kind() == JS_ASSIGNMENT_EXPRESSION)
             {
-                if super_class.syntax().has_leading_comments() || has_trailing_comments {
-                    write!(
-                        f,
-                        [format_parenthesize(
-                            super_class.syntax().first_token().as_ref(),
-                            &content,
-                            super_class.syntax().last_token().as_ref()
-                        )]
-                    )
+                if comments.has_leading_comments(super_class.syntax()) || has_trailing_comments {
+                    write!(f, [text("("), &content, text(")")])
                 } else {
                     let content = content.memoized();
                     write!(
                         f,
                         [
                             if_group_breaks(&format_args![
-                                // Format_inserted is fine here because it is known that super has no comments
-                                format_inserted(JsSyntaxKind::L_PAREN),
+                                text("("),
                                 &soft_block_indent(&content),
-                                format_inserted(JsSyntaxKind::R_PAREN),
+                                text(")"),
                             ]),
                             if_group_fits_on_line(&content)
                         ]
diff --git a/crates/rome_js_formatter/src/js/classes/static_initialization_block_class_member.rs b/crates/rome_js_formatter/src/js/classes/static_initialization_block_class_member.rs
index 560a42ee71c..790fb1e06a6 100644
--- a/crates/rome_js_formatter/src/js/classes/static_initialization_block_class_member.rs
+++ b/crates/rome_js_formatter/src/js/classes/static_initialization_block_class_member.rs
@@ -22,14 +22,26 @@ impl FormatNodeRule<JsStaticInitializationBlockClassMember>
             r_curly_token,
         } = node.as_fields();
 
-        write!(f, [static_token.format(), space()])?;
+        write!(f, [static_token.format(), space(), l_curly_token.format()])?;
 
-        write!(
-            f,
-            [
-                format_delimited(&l_curly_token?, &statements.format(), &r_curly_token?)
-                    .block_indent()
-            ]
-        )
+        if statements.is_empty() {
+            write!(
+                f,
+                [format_dangling_comments(node.syntax()).with_block_indent()]
+            )?;
+        } else {
+            write!(f, [block_indent(&statements.format())])?;
+        }
+
+        write!(f, [r_curly_token.format()])
+    }
+
+    fn fmt_dangling_comments(
+        &self,
+        _: &JsStaticInitializationBlockClassMember,
+        _: &mut JsFormatter,
+    ) -> FormatResult<()> {
+        // Formatted inside of `fmt_fields
+        Ok(())
     }
 }
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 47af6b3a294..af3b42250ea 100644
--- a/crates/rome_js_formatter/src/js/declarations/catch_declaration.rs
+++ b/crates/rome_js_formatter/src/js/declarations/catch_declaration.rs
@@ -16,14 +16,44 @@ impl FormatNodeRule<JsCatchDeclaration> for FormatJsCatchDeclaration {
             type_annotation,
         } = node.as_fields();
 
-        write!(
-            f,
-            [format_delimited(
-                &l_paren_token?,
-                &format_args![binding.format(), type_annotation.format()],
-                &r_paren_token?,
+        let binding = binding?;
+
+        let leading_comment_with_break = f
+            .comments()
+            .leading_comments(binding.syntax())
+            .iter()
+            .any(|comment| comment.lines_after() > 0 || comment.kind().is_line());
+
+        let last_parameter_node = type_annotation
+            .as_ref()
+            .map(|type_annotation| type_annotation.syntax())
+            .unwrap_or_else(|| binding.syntax());
+
+        let trailing_comment_with_break = f
+            .comments()
+            .trailing_comments(last_parameter_node)
+            .iter()
+            .any(|comment| comment.lines_before() > 0 || comment.kind().is_line());
+
+        if leading_comment_with_break || trailing_comment_with_break {
+            write!(
+                f,
+                [
+                    l_paren_token.format(),
+                    soft_block_indent(&format_args![binding.format(), type_annotation.format()]),
+                    r_paren_token.format()
+                ]
+            )
+        } else {
+            write!(
+                f,
+                [
+                    l_paren_token.format(),
+                    binding.format(),
+                    type_annotation.format(),
+                    r_paren_token.format()
+                ]
             )
-            .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 1c7d73fa556..fba585b68c9 100644
--- a/crates/rome_js_formatter/src/js/declarations/class_declaration.rs
+++ b/crates/rome_js_formatter/src/js/declarations/class_declaration.rs
@@ -10,4 +10,13 @@ impl FormatNodeRule<JsClassDeclaration> for FormatJsClassDeclaration {
     fn fmt_fields(&self, node: &JsClassDeclaration, f: &mut JsFormatter) -> FormatResult<()> {
         FormatClass::from(&node.clone().into()).fmt(f)
     }
+
+    fn fmt_dangling_comments(
+        &self,
+        _: &JsClassDeclaration,
+        _: &mut JsFormatter,
+    ) -> FormatResult<()> {
+        // Formatted as part of `FormatClass`
+        Ok(())
+    }
 }
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 56f1bff4023..28dea55b0ba 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
@@ -14,4 +14,13 @@ impl FormatNodeRule<JsClassExportDefaultDeclaration> for FormatJsClassExportDefa
     ) -> FormatResult<()> {
         FormatClass::from(&node.clone().into()).fmt(f)
     }
+
+    fn fmt_dangling_comments(
+        &self,
+        _: &JsClassExportDefaultDeclaration,
+        _: &mut JsFormatter,
+    ) -> FormatResult<()> {
+        /* Formatted as part of `FormatClass` */
+        Ok(())
+    }
 }
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 57a23de71c2..279afab1531 100644
--- a/crates/rome_js_formatter/src/js/declarations/function_declaration.rs
+++ b/crates/rome_js_formatter/src/js/declarations/function_declaration.rs
@@ -207,21 +207,10 @@ pub(crate) fn should_group_function_parameters(
     let result = if parameter_count != 1 {
         false
     } else {
-        // TODO https://github.com/rome/tools/issues/2768
-        // THIS is a hack that is necessary to avoid that the formatter doesn't insert a space
-        // between `)` and the `:` of the return type annotation IF there's a an inline comment
-        // after the last comment that has been written. This can be deleted once the comments refactor lands.
-        let is_last_content_inline_comment = f.state().is_last_content_inline_comment();
-        f.state_mut().set_last_content_inline_comment(false);
-
-        let group = matches!(
+        matches!(
             return_type,
             TsAnyReturnType::TsType(TsType::TsObjectType(_) | TsType::TsMappedType(_))
-        ) || formatted_return_type.inspect(f)?.will_break();
-
-        f.state_mut()
-            .set_last_content_inline_comment(is_last_content_inline_comment);
-        group
+        ) || formatted_return_type.inspect(f)?.will_break()
     };
 
     Ok(result)
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 1e6dfd0aac3..901284c6ee8 100644
--- a/crates/rome_js_formatter/src/js/expressions/array_expression.rs
+++ b/crates/rome_js_formatter/src/js/expressions/array_expression.rs
@@ -19,12 +19,24 @@ impl FormatNodeRule<JsArrayExpression> for FormatJsArrayExpression {
             r_brack_token,
         } = node.as_fields();
 
-        if should_break(&elements)? {
+        let r_brack_token = r_brack_token?;
+
+        if elements.is_empty() {
+            write!(
+                f,
+                [
+                    l_brack_token.format(),
+                    format_dangling_comments(node.syntax()).with_block_indent(),
+                    r_brack_token.format(),
+                ]
+            )
+        } else if should_break(&elements)? {
             write!(
                 f,
                 [
-                    format_delimited(&l_brack_token?, &elements.format(), &r_brack_token?)
-                        .block_indent()
+                    l_brack_token.format(),
+                    block_indent(&elements.format()),
+                    r_brack_token.format()
                 ]
             )
         } else {
@@ -35,8 +47,9 @@ impl FormatNodeRule<JsArrayExpression> for FormatJsArrayExpression {
             write!(
                 f,
                 [
-                    format_delimited(&l_brack_token?, &elements, &r_brack_token?)
-                        .soft_block_indent_with_group_id(Some(group_id))
+                    l_brack_token.format(),
+                    group(&soft_block_indent(&elements)).with_group_id(Some(group_id)),
+                    r_brack_token.format()
                 ]
             )
         }
@@ -45,6 +58,15 @@ impl FormatNodeRule<JsArrayExpression> for FormatJsArrayExpression {
     fn needs_parentheses(&self, item: &JsArrayExpression) -> bool {
         item.needs_parentheses()
     }
+
+    fn fmt_dangling_comments(
+        &self,
+        _: &JsArrayExpression,
+        _: &mut JsFormatter,
+    ) -> FormatResult<()> {
+        // Formatted inside of `fmt_fields`
+        Ok(())
+    }
 }
 
 /// Returns `true` for arrays containing at least two elements if:
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 d705c509534..09dfd0afc87 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
@@ -1,5 +1,5 @@
 use crate::prelude::*;
-use rome_formatter::{format_args, write, Comments, CstFormatContext, FormatRuleWithOptions};
+use rome_formatter::{format_args, write, CstFormatContext, FormatRuleWithOptions};
 use std::iter::once;
 
 use crate::parentheses::{
@@ -11,7 +11,7 @@ use crate::utils::{
 };
 use rome_js_syntax::{
     JsAnyArrowFunctionParameters, JsAnyBindingPattern, JsAnyExpression, JsAnyFormalParameter,
-    JsAnyFunctionBody, JsAnyParameter, JsAnyTemplateElement, JsArrowFunctionExpression, JsLanguage,
+    JsAnyFunctionBody, JsAnyParameter, JsAnyTemplateElement, JsArrowFunctionExpression,
     JsSyntaxKind, JsSyntaxNode, JsTemplate,
 };
 use rome_rowan::SyntaxResult;
@@ -107,6 +107,10 @@ impl FormatNodeRule<JsArrowFunctionExpression> for FormatJsArrowFunctionExpressi
                         _ => false,
                     },
                 };
+                let body_has_leading_line_comment = f
+                    .context()
+                    .comments()
+                    .has_leading_own_line_comment(body.syntax());
 
                 // Add parentheses to avoid confusion between `a => b ? c : d` and `a <= b ? c : d`
                 // but only if the body isn't an object/function or class expression because parentheses are always required in that
@@ -128,7 +132,8 @@ impl FormatNodeRule<JsArrowFunctionExpression> for FormatJsArrowFunctionExpressi
                     _ => false,
                 };
 
-                if body_has_soft_line_break && !should_add_parens {
+                if body_has_soft_line_break && !should_add_parens && !body_has_leading_line_comment
+                {
                     write![f, [format_signature, space(), body.format()]]
                 } else {
                     write!(
@@ -158,6 +163,15 @@ impl FormatNodeRule<JsArrowFunctionExpression> for FormatJsArrowFunctionExpressi
     fn needs_parentheses(&self, item: &JsArrowFunctionExpression) -> bool {
         item.needs_parentheses()
     }
+
+    fn fmt_dangling_comments(
+        &self,
+        _: &JsArrowFunctionExpression,
+        _: &mut JsFormatter,
+    ) -> FormatResult<()> {
+        // Formatted inside of `fmt_fields`
+        Ok(())
+    }
 }
 
 /// writes the arrow function type parameters, parameters, and return type annotation
@@ -173,14 +187,14 @@ fn format_signature(arrow: &JsArrowFunctionExpression) -> impl Format<JsFormatCo
             match arrow.parameters()? {
                 JsAnyArrowFunctionParameters::JsAnyBinding(binding) => write!(
                     f,
-                    [format_parenthesize(
-                        binding.syntax().first_token().as_ref(),
+                    [
+                        text("("),
                         &soft_block_indent(&format_args![
                             binding.format(),
                             if_group_breaks(&text(","))
                         ]),
-                        binding.syntax().last_token().as_ref(),
-                    )]
+                        text(")")
+                    ]
                 )?,
                 JsAnyArrowFunctionParameters::JsParameters(params) => {
                     write!(f, [params.format()])?;
@@ -190,7 +204,13 @@ fn format_signature(arrow: &JsArrowFunctionExpression) -> impl Format<JsFormatCo
             write!(f, [arrow.return_type_annotation().format()])
         });
 
-        write!(f, [group(&format_parameters)])
+        write!(f, [group(&format_parameters)])?;
+
+        if f.comments().has_dangling_comments(arrow.syntax()) {
+            write!(f, [space(), format_dangling_comments(arrow.syntax())])?;
+        }
+
+        Ok(())
     })
 }
 
@@ -330,7 +350,13 @@ impl Format<JsFormatContext> for ArrowChain {
 
             let join_signatures = format_with(|f| {
                 for arrow in self.arrows() {
-                    write!(f, [format_signature(arrow)])?;
+                    write!(
+                        f,
+                        [
+                            format_leading_comments(arrow.syntax()),
+                            format_signature(arrow)
+                        ]
+                    )?;
 
                     // The arrow of the tail is formatted outside of the group to ensure it never
                     // breaks from the body
@@ -365,9 +391,9 @@ impl Format<JsFormatContext> for ArrowChain {
                 write!(
                     f,
                     [group(&format_args![
-                        format_inserted(JsSyntaxKind::L_PAREN,),
+                        text("("),
                         soft_block_indent(&tail_body.format()),
-                        format_inserted(JsSyntaxKind::R_PAREN)
+                        text(")")
                     ])]
                 )
             } else {
@@ -423,7 +449,7 @@ impl ArrowFunctionLayout {
     /// of the different layouts.
     fn for_arrow(
         arrow: JsArrowFunctionExpression,
-        comments: &Comments<JsLanguage>,
+        comments: &JsComments,
         assignment_layout: Option<AssignmentLikeLayout>,
     ) -> SyntaxResult<ArrowFunctionLayout> {
         let mut head = None;
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 036ed23da42..ab166b2be4f 100644
--- a/crates/rome_js_formatter/src/js/expressions/call_arguments.rs
+++ b/crates/rome_js_formatter/src/js/expressions/call_arguments.rs
@@ -1,11 +1,10 @@
-use crate::builders::{format_close_delimiter, format_open_delimiter};
 use crate::prelude::*;
 use crate::utils::{is_call_like_expression, write_arguments_multi_line};
-use rome_formatter::{format_args, write};
+use rome_formatter::{format_args, write, CstFormatContext};
 use rome_js_syntax::{
     JsAnyCallArgument, JsAnyExpression, JsAnyFunctionBody, JsAnyLiteralExpression, JsAnyName,
     JsAnyStatement, JsArrayExpression, JsArrowFunctionExpression, JsCallArgumentList,
-    JsCallArguments, JsCallArgumentsFields, JsCallExpression, JsSyntaxKind, TsReferenceType,
+    JsCallArguments, JsCallArgumentsFields, JsCallExpression, TsReferenceType,
 };
 use rome_rowan::{AstSeparatedList, SyntaxResult, SyntaxTokenText};
 
@@ -28,7 +27,7 @@ impl FormatNodeRule<JsCallArguments> for FormatJsCallArguments {
                 f,
                 [
                     l_paren_token.format(),
-                    args.format(),
+                    format_dangling_comments(node.syntax()).with_soft_block_indent(),
                     r_paren_token.format()
                 ]
             );
@@ -58,14 +57,16 @@ impl FormatNodeRule<JsCallArguments> for FormatJsCallArguments {
                     false
                 };
 
-            let is_react_hook_with_deps_array =
-                is_react_hook_with_deps_array(&first_argument, &second_argument)?
-                    && !node.syntax().first_or_last_token_have_comments();
+            let is_react_hook_with_deps_array = is_react_hook_with_deps_array(
+                &first_argument,
+                &second_argument,
+                f.context().comments(),
+            )?;
 
             if is_framework_test_call || is_react_hook_with_deps_array {
                 write!(f, [l_paren_token.format(),])?;
                 let separated = args
-                    .format_separated(JsSyntaxKind::COMMA)
+                    .format_separated(",")
                     .with_trailing_separator(TrailingSeparator::Omit);
 
                 f.join_with(space()).entries(separated).finish()?;
@@ -73,23 +74,16 @@ impl FormatNodeRule<JsCallArguments> for FormatJsCallArguments {
             }
         };
 
-        // we create open a close delimiters
-        let open_delimiter = format_open_delimiter(&l_paren_token);
-        let close_delimiter = format_close_delimiter(&r_paren_token);
-
         // we now extracts the formatted version of trivias and tokens of the delimiters
         // tokens on the left
-        let l_leading_trivia = open_delimiter.format_leading_trivia();
-        let l_paren = open_delimiter.format_token();
-        let l_trailing_trivia = open_delimiter.format_trailing_trivia();
+        let l_paren = l_paren_token.format();
 
         // tokens on the right
-        let r_leading_trivia = close_delimiter.format_leading_trivia();
-        let r_paren = close_delimiter.format_token();
-        let r_trailing_trivia = close_delimiter.format_trailing_trivia();
+        let r_paren = r_paren_token.format();
 
-        let should_group_first_argument = should_group_first_argument(&args)?;
-        let should_group_last_argument = should_group_last_argument(&args)?;
+        let comments = f.context().comments();
+        let should_group_first_argument = should_group_first_argument(&args, comments)?;
+        let should_group_last_argument = should_group_last_argument(&args, comments)?;
 
         // if the first or last groups needs grouping, then we prepare some special formatting
         if should_group_first_argument || should_group_last_argument {
@@ -98,7 +92,7 @@ impl FormatNodeRule<JsCallArguments> for FormatJsCallArguments {
             // we can't attempt to print the same node twice without incur in "printed token twice" errors.
             // We also disallow the trailing separator, we are interested in doing it manually.
             let mut separated: Vec<_> = args
-                .format_separated(JsSyntaxKind::COMMA)
+                .format_separated(",")
                 .with_trailing_separator(TrailingSeparator::Omit)
                 .map(|e| e.memoized())
                 .collect();
@@ -120,14 +114,10 @@ impl FormatNodeRule<JsCallArguments> for FormatJsCallArguments {
             // We now cache them the delimiters tokens. This is needed because `[rome_formatter::best_fitting]` will try to
             // print each version first
             // tokens on the left
-            let l_leading_trivia = l_leading_trivia.memoized();
             let l_paren = l_paren.memoized();
-            let l_trailing_trivia = l_trailing_trivia.memoized();
 
             // tokens on the right
-            let r_leading_trivia = r_leading_trivia.memoized();
             let r_paren = r_paren.memoized();
-            let r_trailing_trivia = r_trailing_trivia.memoized();
 
             // This is the version of where all the arguments are broken out
             let all_arguments_expanded = format_with(|f| {
@@ -136,25 +126,21 @@ impl FormatNodeRule<JsCallArguments> for FormatJsCallArguments {
                 write!(
                     f,
                     [
-                        &l_leading_trivia,
                         &l_paren,
                         &group(&format_with(|f| {
                             write!(
                                 f,
                                 [
                                     &soft_block_indent(&format_args![
-                                        &l_trailing_trivia,
                                         format_with(|f| {
                                             write_arguments_multi_line(separated.iter(), f)
                                         }),
-                                        &r_leading_trivia,
                                         soft_line_break()
                                     ]),
                                     &r_paren
                                 ]
                             )
                         })),
-                        &r_trailing_trivia
                     ]
                 )
             });
@@ -168,7 +154,7 @@ impl FormatNodeRule<JsCallArguments> for FormatJsCallArguments {
                 // which means that if one is `false`, then the other is `true`.
                 // This means that in this branch we format the case where `should_group_first_argument`,
                 // in the else branch we format the case where `should_group_last_argument` is `true`.
-                write!(f, [l_leading_trivia, l_paren, l_trailing_trivia,])?;
+                write!(f, [l_paren])?;
                 if should_group_first_argument {
                     // special formatting of the first element
                     let mut iter = separated.iter();
@@ -193,22 +179,18 @@ impl FormatNodeRule<JsCallArguments> for FormatJsCallArguments {
                         }))
                         .finish()?;
                 }
-                write!(f, [r_leading_trivia, r_paren, r_trailing_trivia])
+                write!(f, [r_paren])
             });
 
             write!(
                 f,
                 [best_fitting![
                     format_args![
-                        l_leading_trivia,
                         l_paren,
-                        l_trailing_trivia,
                         group(&format_with(|f| {
                             write_arguments_multi_line(separated.iter(), f)
                         })),
-                        r_leading_trivia,
                         r_paren,
-                        r_trailing_trivia
                     ],
                     edge_arguments_do_not_break,
                     all_arguments_expanded
@@ -217,30 +199,32 @@ impl FormatNodeRule<JsCallArguments> for FormatJsCallArguments {
         } else {
             write!(
                 f,
-                [
-                    l_leading_trivia,
-                    group(&format_args![
-                        l_paren,
-                        l_trailing_trivia,
-                        soft_block_indent(&format_with(|f| {
-                            let separated = args
-                                .format_separated(JsSyntaxKind::COMMA)
-                                .with_trailing_separator(TrailingSeparator::Omit)
-                                .nodes_grouped();
-                            write_arguments_multi_line(separated, f)
-                        })),
-                        r_leading_trivia,
-                        r_paren,
-                    ]),
-                    r_trailing_trivia
-                ]
+                [group(&format_args![
+                    l_paren,
+                    soft_block_indent(&format_with(|f| {
+                        let separated = args
+                            .format_separated(",")
+                            .with_trailing_separator(TrailingSeparator::Omit)
+                            .nodes_grouped();
+                        write_arguments_multi_line(separated, f)
+                    })),
+                    r_paren,
+                ]),]
             )
         }
     }
+
+    fn fmt_dangling_comments(&self, _: &JsCallArguments, _: &mut JsFormatter) -> FormatResult<()> {
+        // Formatted inside of `fmt_fields`
+        Ok(())
+    }
 }
 
 /// Checks if the the first argument requires grouping
-fn should_group_first_argument(list: &JsCallArgumentList) -> SyntaxResult<bool> {
+fn should_group_first_argument(
+    list: &JsCallArgumentList,
+    comments: &JsComments,
+) -> SyntaxResult<bool> {
     if list.len() != 2 {
         return Ok(false);
     }
@@ -249,8 +233,6 @@ fn should_group_first_argument(list: &JsCallArgumentList) -> SyntaxResult<bool>
     let first = iter.next().unwrap()?;
     let second = iter.next().unwrap()?;
 
-    let has_comments = first.syntax().has_comments_direct();
-
     let is_function_like = match first.as_js_any_expression() {
         Some(JsAnyExpression::JsFunctionExpression(_)) => true,
         Some(JsAnyExpression::JsArrowFunctionExpression(arrow)) => {
@@ -269,17 +251,23 @@ fn should_group_first_argument(list: &JsCallArgumentList) -> SyntaxResult<bool>
             );
             (
                 second_arg_is_function_like,
-                could_group_expression_argument(second_expression, false)?,
+                could_group_expression_argument(second_expression, false, comments)?,
             )
         }
         None => (false, false),
     };
 
-    Ok(!has_comments && is_function_like && !second_arg_is_function_like && !can_group)
+    Ok(!comments.has_comments(first.syntax())
+        && is_function_like
+        && !second_arg_is_function_like
+        && !can_group)
 }
 
 /// Checks if the last group requires grouping
-fn should_group_last_argument(list: &JsCallArgumentList) -> SyntaxResult<bool> {
+fn should_group_last_argument(
+    list: &JsCallArgumentList,
+    comments: &JsComments,
+) -> SyntaxResult<bool> {
     let list_len = list.len();
     let mut iter = list.iter();
     let last = iter.next_back();
@@ -305,12 +293,15 @@ fn should_group_last_argument(list: &JsCallArgumentList) -> SyntaxResult<bool> {
 
         let can_group = match &last {
             JsAnyCallArgument::JsAnyExpression(expression) => {
-                could_group_expression_argument(expression, false)?
+                could_group_expression_argument(expression, false, comments)?
             }
             _ => false,
         };
 
-        Ok(!last.syntax().has_comments_direct() && can_group && check_with_penultimate)
+        Ok(!comments.has_leading_comments(last.syntax())
+            && !comments.has_trailing_comments(last.syntax())
+            && can_group
+            && check_with_penultimate)
     } else {
         Ok(false)
     }
@@ -320,27 +311,24 @@ fn should_group_last_argument(list: &JsCallArgumentList) -> SyntaxResult<bool> {
 fn could_group_expression_argument(
     argument: &JsAnyExpression,
     is_arrow_recursion: bool,
+    comments: &JsComments,
 ) -> SyntaxResult<bool> {
     let result = match argument {
         JsAnyExpression::JsObjectExpression(object_expression) => {
             object_expression.members().len() > 0
-                || object_expression
-                    .syntax()
-                    .first_or_last_token_have_comments()
+                || comments.has_comments(object_expression.syntax())
         }
 
         JsAnyExpression::JsArrayExpression(array_expression) => {
             array_expression.elements().len() > 0
-                || array_expression
-                    .syntax()
-                    .first_or_last_token_have_comments()
+                || comments.has_comments(array_expression.syntax())
         }
         JsAnyExpression::TsTypeAssertionExpression(assertion_expression) => {
-            could_group_expression_argument(&assertion_expression.expression()?, false)?
+            could_group_expression_argument(&assertion_expression.expression()?, false, comments)?
         }
 
         JsAnyExpression::TsAsExpression(as_expression) => {
-            could_group_expression_argument(&as_expression.expression()?, false)?
+            could_group_expression_argument(&as_expression.expression()?, false, comments)?
         }
         JsAnyExpression::JsArrowFunctionExpression(arrow_function) => {
             let body = arrow_function.body()?;
@@ -395,7 +383,9 @@ fn could_group_expression_argument(
                             .body()
                             .ok()
                             .and_then(|body| body.as_js_any_expression().cloned())
-                            .and_then(|body| could_group_expression_argument(&body, true).ok())
+                            .and_then(|body| {
+                                could_group_expression_argument(&body, true, comments).ok()
+                            })
                             .unwrap_or(false)
                     } else {
                         false
@@ -430,7 +420,14 @@ fn could_group_expression_argument(
 fn is_react_hook_with_deps_array(
     first_argument: &JsAnyCallArgument,
     second_argument: &JsAnyCallArgument,
+    comments: &JsComments,
 ) -> SyntaxResult<bool> {
+    if comments.has_comments(first_argument.syntax())
+        || comments.has_comments(second_argument.syntax())
+    {
+        return Ok(false);
+    }
+
     let first_expression = match first_argument {
         JsAnyCallArgument::JsAnyExpression(expression) => Some(expression),
         _ => None,
@@ -450,7 +447,6 @@ fn is_react_hook_with_deps_array(
     };
 
     let second_node_matches = matches!(second_argument, JsAnyCallArgument::JsAnyExpression(_));
-    // let no_comments = !node.syntax().first_or_last_token_have_comments();
     if first_node_matches && second_node_matches {
         Ok(true)
     } else {
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 45951b11812..ace2f775bca 100644
--- a/crates/rome_js_formatter/src/js/expressions/class_expression.rs
+++ b/crates/rome_js_formatter/src/js/expressions/class_expression.rs
@@ -17,6 +17,15 @@ impl FormatNodeRule<JsClassExpression> for FormatJsClassExpression {
     fn needs_parentheses(&self, item: &JsClassExpression) -> bool {
         item.needs_parentheses()
     }
+
+    fn fmt_dangling_comments(
+        &self,
+        _: &JsClassExpression,
+        _: &mut JsFormatter,
+    ) -> FormatResult<()> {
+        // Formatted as part of `FormatClass`
+        Ok(())
+    }
 }
 
 impl NeedsParentheses for JsClassExpression {
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 cc95edbf40e..5016238f2d2 100644
--- a/crates/rome_js_formatter/src/js/expressions/new_expression.rs
+++ b/crates/rome_js_formatter/src/js/expressions/new_expression.rs
@@ -32,13 +32,7 @@ impl FormatNodeRule<JsNewExpression> for FormatJsNewExpression {
                 write!(f, [arguments.format()])
             }
             None => {
-                write!(
-                    f,
-                    [
-                        format_inserted(JsSyntaxKind::L_PAREN),
-                        format_inserted(JsSyntaxKind::R_PAREN)
-                    ]
-                )
+                write!(f, [text("("), text(")")])
             }
         }
     }
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 0a58a3d8eb7..93ace848894 100644
--- a/crates/rome_js_formatter/src/js/expressions/object_expression.rs
+++ b/crates/rome_js_formatter/src/js/expressions/object_expression.rs
@@ -15,6 +15,15 @@ impl FormatNodeRule<JsObjectExpression> for FormatJsObjectExpression {
     fn needs_parentheses(&self, item: &JsObjectExpression) -> bool {
         item.needs_parentheses()
     }
+
+    fn fmt_dangling_comments(
+        &self,
+        _: &JsObjectExpression,
+        _: &mut JsFormatter,
+    ) -> FormatResult<()> {
+        // Formatted inside of `JsObjectLike`
+        Ok(())
+    }
 }
 
 impl NeedsParentheses for JsObjectExpression {
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 6b773b44a84..89cd60ea3c8 100644
--- a/crates/rome_js_formatter/src/js/expressions/parenthesized_expression.rs
+++ b/crates/rome_js_formatter/src/js/expressions/parenthesized_expression.rs
@@ -1,5 +1,5 @@
 use crate::prelude::*;
-use rome_formatter::{format_args, write};
+use rome_formatter::{format_args, write, CstFormatContext};
 
 use crate::parentheses::NeedsParentheses;
 use rome_js_syntax::{
@@ -23,9 +23,9 @@ impl FormatNodeRule<JsParenthesizedExpression> for FormatJsParenthesizedExpressi
 
         let l_paren_token = l_paren_token?;
         let expression = expression?;
+        let comments = f.context().comments();
 
-        let should_hug = !(expression.syntax().has_comments_direct()
-            || l_paren_token.has_trailing_comments())
+        let should_hug = !comments.has_comments(expression.syntax())
             && (matches!(
                 expression,
                 JsAnyExpression::JsObjectExpression(_) | JsAnyExpression::JsArrayExpression(_)
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 ac176e79ce6..6b413391bd7 100644
--- a/crates/rome_js_formatter/src/js/expressions/template_element.rs
+++ b/crates/rome_js_formatter/src/js/expressions/template_element.rs
@@ -1,6 +1,8 @@
 use crate::prelude::*;
 use rome_formatter::printer::{PrintWidth, Printer};
-use rome_formatter::{format_args, write, FormatOptions, FormatRuleWithOptions, VecBuffer};
+use rome_formatter::{
+    format_args, write, CstFormatContext, FormatOptions, FormatRuleWithOptions, VecBuffer,
+};
 
 use crate::context::TabWidth;
 use crate::js::lists::template_element_list::{TemplateElementIndention, TemplateElementLayout};
@@ -63,8 +65,6 @@ impl FormatTemplateElement {
 
 impl Format<JsFormatContext> for FormatTemplateElement {
     fn fmt(&self, f: &mut JsFormatter) -> FormatResult<()> {
-        let has_comments = self.element.syntax().has_comments_direct();
-
         let format_expression = format_with(|f| match &self.element {
             AnyTemplateElement::JsTemplateElement(template) => {
                 write!(f, [template.expression().format()])
@@ -110,7 +110,10 @@ impl Format<JsFormatContext> for FormatTemplateElement {
 
                 // It's preferred to break after/before `${` and `}` rather than breaking in the
                 // middle of some expressions.
-                let indent = has_comments
+                let indent = f
+                    .context()
+                    .comments()
+                    .has_comments(&self.element.inner_syntax()?)
                     || matches!(
                         expression,
                         Some(
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 5e54eebca4c..eae44ac6aa1 100644
--- a/crates/rome_js_formatter/src/js/expressions/unary_expression.rs
+++ b/crates/rome_js_formatter/src/js/expressions/unary_expression.rs
@@ -1,10 +1,10 @@
 use crate::prelude::*;
-use rome_formatter::{format_args, write};
+use rome_formatter::{format_args, write, CstFormatContext};
 
 use crate::parentheses::{unary_like_expression_needs_parentheses, NeedsParentheses};
 
 use rome_js_syntax::JsSyntaxNode;
-use rome_js_syntax::{JsSyntaxKind, JsUnaryExpression};
+use rome_js_syntax::JsUnaryExpression;
 use rome_js_syntax::{JsUnaryExpressionFields, JsUnaryOperator};
 use rome_rowan::match_ast;
 
@@ -33,13 +33,13 @@ impl FormatNodeRule<JsUnaryExpression> for FormatJsUnaryExpression {
             write!(f, [space()])?;
         }
 
-        if argument.syntax().has_leading_comments() {
+        if f.context().comments().has_comments(argument.syntax()) {
             write!(
                 f,
                 [group(&format_args![
-                    format_inserted(JsSyntaxKind::L_PAREN),
+                    text("("),
                     soft_block_indent(&argument.format()),
-                    format_inserted(JsSyntaxKind::R_PAREN)
+                    text(")")
                 ])]
             )
         } else {
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 18250a5d941..c864ceb4b95 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
@@ -1,10 +1,9 @@
 use crate::prelude::*;
-use rome_formatter::{write, FormatRuleWithOptions, GroupId};
+use rome_formatter::{write, CstFormatContext, FormatRuleWithOptions, GroupId};
 
 use crate::utils::array::write_array_node;
 
-use crate::utils::{has_token_trailing_line_comment, has_trailing_line_comment};
-use rome_js_syntax::{JsArrayElementList, JsSyntaxKind};
+use rome_js_syntax::JsArrayElementList;
 use rome_rowan::{AstNode, AstSeparatedList};
 
 #[derive(Debug, Clone, Default)]
@@ -25,7 +24,7 @@ impl FormatRule<JsArrayElementList> for FormatJsArrayElementList {
     type Context = JsFormatContext;
 
     fn fmt(&self, node: &JsArrayElementList, f: &mut JsFormatter) -> FormatResult<()> {
-        let layout = if can_print_fill(node) {
+        let layout = if can_print_fill(node, f.context().comments()) {
             ArrayLayout::Fill
         } else {
             ArrayLayout::OnePerLine
@@ -36,10 +35,10 @@ impl FormatRule<JsArrayElementList> for FormatJsArrayElementList {
                 let mut filler = f.fill();
 
                 // Using format_separated is valid in this case as can_print_fill does not allow holes
-                for (element, formatted) in node.iter().zip(
-                    node.format_separated(JsSyntaxKind::COMMA)
-                        .with_group_id(self.group_id),
-                ) {
+                for (element, formatted) in node
+                    .iter()
+                    .zip(node.format_separated(",").with_group_id(self.group_id))
+                {
                     filler.entry(
                         &format_once(|f| {
                             if get_lines_before(element?.syntax()) > 1 {
@@ -90,7 +89,7 @@ enum ArrayLayout {
 /// The underlying logic only allows lists of literal expressions
 /// with 10 or less characters, potentially wrapped in a "short"
 /// unary expression (+, -, ~ or !)
-fn can_print_fill(list: &JsArrayElementList) -> bool {
+fn can_print_fill(list: &JsArrayElementList, comments: &JsComments) -> bool {
     use rome_js_syntax::JsAnyArrayElement::*;
     use rome_js_syntax::JsAnyExpression::*;
     use rome_js_syntax::JsUnaryOperator::*;
@@ -100,16 +99,6 @@ fn can_print_fill(list: &JsArrayElementList) -> bool {
     }
 
     list.elements().all(|item| {
-        let separator_has_trailing = item.trailing_separator().map_or(true, |separator| {
-            separator.map_or(false, |separator| {
-                has_token_trailing_line_comment(separator)
-            })
-        });
-
-        if separator_has_trailing {
-            return false;
-        }
-
         let syntax = match item.into_node() {
             Ok(JsAnyExpression(JsAnyLiteralExpression(
                 rome_js_syntax::JsAnyLiteralExpression::JsNumberLiteralExpression(literal),
@@ -123,15 +112,8 @@ fn can_print_fill(list: &JsArrayElementList) -> bool {
                     Ok(JsAnyLiteralExpression(
                         rome_js_syntax::JsAnyLiteralExpression::JsNumberLiteralExpression(literal),
                     )) => {
-                        let has_operator_comments = expr
-                            .operator_token()
-                            .map_or(false, |operator| operator.has_trailing_comments());
-
-                        if signed
-                            && !literal.syntax().has_leading_comments()
-                            && !has_operator_comments
-                        {
-                            literal.into_syntax()
+                        if signed && !comments.has_comments(literal.syntax()) {
+                            expr.into_syntax()
                         } else {
                             return false;
                         }
@@ -147,6 +129,20 @@ fn can_print_fill(list: &JsArrayElementList) -> bool {
             }
         };
 
-        !has_trailing_line_comment(&syntax)
+        // Does not have a line comment ending on the same line
+        // ```javascript
+        // [ a // not this
+        //  b];
+        //
+        // [
+        //   // This is fine
+        //   thats
+        // ]
+        // ```
+        !comments
+            .trailing_comments(&syntax)
+            .iter()
+            .filter(|comment| comment.kind().is_line())
+            .any(|comment| comment.lines_before() == 0)
     })
 }
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 f36afa497a2..cb939ee7d32 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
@@ -1,7 +1,7 @@
 use crate::prelude::*;
 use crate::utils::write_arguments_multi_line;
 use rome_formatter::write;
-use rome_js_syntax::{JsCallArgumentList, JsSyntaxKind};
+use rome_js_syntax::JsCallArgumentList;
 
 #[derive(Debug, Clone, Default)]
 pub struct FormatJsCallArgumentList;
@@ -18,7 +18,7 @@ impl FormatRule<JsCallArgumentList> for FormatJsCallArgumentList {
             f,
             [&group(&soft_block_indent(&format_with(|f| {
                 let separated = node
-                    .format_separated(JsSyntaxKind::COMMA)
+                    .format_separated(",")
                     .with_trailing_separator(TrailingSeparator::Omit);
                 write_arguments_multi_line(separated, f)
             })))]
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 07f2d09095a..a185765e85a 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
@@ -1,5 +1,5 @@
 use crate::prelude::*;
-use rome_js_syntax::{JsExportNamedFromSpecifierList, JsSyntaxKind};
+use rome_js_syntax::JsExportNamedFromSpecifierList;
 
 #[derive(Debug, Clone, Default)]
 pub struct FormatJsExportNamedFromSpecifierList;
@@ -9,7 +9,7 @@ impl FormatRule<JsExportNamedFromSpecifierList> for FormatJsExportNamedFromSpeci
 
     fn fmt(&self, node: &JsExportNamedFromSpecifierList, f: &mut JsFormatter) -> FormatResult<()> {
         f.join_with(&soft_line_break_or_space())
-            .entries(node.format_separated(JsSyntaxKind::COMMA))
+            .entries(node.format_separated(","))
             .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 0f1bda76b46..11df691d86f 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
@@ -1,5 +1,5 @@
 use crate::prelude::*;
-use rome_js_syntax::{JsExportNamedSpecifierList, JsSyntaxKind};
+use rome_js_syntax::JsExportNamedSpecifierList;
 
 #[derive(Debug, Clone, Default)]
 pub struct FormatJsExportNamedSpecifierList;
@@ -9,7 +9,7 @@ impl FormatRule<JsExportNamedSpecifierList> for FormatJsExportNamedSpecifierList
 
     fn fmt(&self, node: &JsExportNamedSpecifierList, f: &mut JsFormatter) -> FormatResult<()> {
         f.join_with(&soft_line_break_or_space())
-            .entries(node.format_separated(JsSyntaxKind::COMMA))
+            .entries(node.format_separated(","))
             .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 dcfeb474825..1d09d2ccbac 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
@@ -1,5 +1,5 @@
 use crate::prelude::*;
-use rome_js_syntax::{JsImportAssertionEntryList, JsSyntaxKind};
+use rome_js_syntax::JsImportAssertionEntryList;
 
 #[derive(Debug, Clone, Default)]
 pub struct FormatJsImportAssertionEntryList;
@@ -9,7 +9,7 @@ impl FormatRule<JsImportAssertionEntryList> for FormatJsImportAssertionEntryList
 
     fn fmt(&self, node: &JsImportAssertionEntryList, f: &mut JsFormatter) -> FormatResult<()> {
         f.join_with(&soft_line_break_or_space())
-            .entries(node.format_separated(JsSyntaxKind::COMMA))
+            .entries(node.format_separated(","))
             .finish()
     }
 }
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 1eb56aac5f7..f9dd9876147 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
@@ -1,5 +1,5 @@
 use crate::prelude::*;
-use rome_js_syntax::{JsNamedImportSpecifierList, JsSyntaxKind};
+use rome_js_syntax::JsNamedImportSpecifierList;
 
 #[derive(Debug, Clone, Default)]
 pub struct FormatJsNamedImportSpecifierList;
@@ -9,7 +9,7 @@ impl FormatRule<JsNamedImportSpecifierList> for FormatJsNamedImportSpecifierList
 
     fn fmt(&self, node: &JsNamedImportSpecifierList, f: &mut JsFormatter) -> FormatResult<()> {
         f.join_with(&soft_line_break_or_space())
-            .entries(node.format_separated(JsSyntaxKind::COMMA))
+            .entries(node.format_separated(","))
             .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 0fbfe3fae6d..334430a4324 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
@@ -1,7 +1,5 @@
 use crate::prelude::*;
-use rome_js_syntax::{
-    JsAnyObjectAssignmentPatternMember, JsObjectAssignmentPatternPropertyList, JsSyntaxKind,
-};
+use rome_js_syntax::{JsAnyObjectAssignmentPatternMember, JsObjectAssignmentPatternPropertyList};
 
 #[derive(Debug, Clone, Default)]
 pub struct FormatJsObjectAssignmentPatternPropertyList;
@@ -32,7 +30,7 @@ impl FormatRule<JsObjectAssignmentPatternPropertyList>
         };
 
         let entries = node
-            .format_separated(JsSyntaxKind::COMMA)
+            .format_separated(",")
             .with_trailing_separator(trailing_separator)
             .zip(node.iter());
 
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 e6a9034bab8..9d795715d19 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
@@ -1,7 +1,5 @@
 use crate::prelude::*;
-use rome_js_syntax::{
-    JsAnyObjectBindingPatternMember, JsObjectBindingPatternPropertyList, JsSyntaxKind,
-};
+use rome_js_syntax::{JsAnyObjectBindingPatternMember, JsObjectBindingPatternPropertyList};
 
 #[derive(Debug, Clone, Default)]
 pub struct FormatJsObjectBindingPatternPropertyList;
@@ -30,7 +28,7 @@ impl FormatRule<JsObjectBindingPatternPropertyList> for FormatJsObjectBindingPat
         };
 
         let entries = node
-            .format_separated(JsSyntaxKind::COMMA)
+            .format_separated(",")
             .with_trailing_separator(trailing_separator)
             .zip(node.iter());
 
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 683c9c85a5c..057f60a1ef5 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
@@ -1,5 +1,5 @@
 use crate::prelude::*;
-use rome_js_syntax::{JsObjectMemberList, JsSyntaxKind};
+use rome_js_syntax::JsObjectMemberList;
 use rome_rowan::{AstNode, AstSeparatedList};
 
 #[derive(Debug, Clone, Default)]
@@ -11,10 +11,7 @@ impl FormatRule<JsObjectMemberList> for FormatJsObjectMemberList {
     fn fmt(&self, 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(JsSyntaxKind::COMMA))
-        {
+        for (element, formatted) in node.elements().zip(node.format_separated(",")) {
             join.entry(element.node()?.syntax(), &formatted);
         }
 
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 e48d6897dc5..88cd070480b 100644
--- a/crates/rome_js_formatter/src/js/lists/parameter_list.rs
+++ b/crates/rome_js_formatter/src/js/lists/parameter_list.rs
@@ -3,7 +3,7 @@ use crate::prelude::*;
 
 use rome_js_syntax::{
     JsAnyConstructorParameter, JsAnyParameter, JsConstructorParameterList, JsLanguage,
-    JsParameterList, JsSyntaxKind,
+    JsParameterList,
 };
 use rome_rowan::{declare_node_union, AstSeparatedListNodesIterator, SyntaxResult};
 
@@ -40,7 +40,7 @@ impl<'a> FormatJsAnyParameterList<'a> {
 impl Format<JsFormatContext> for FormatJsAnyParameterList<'_> {
     fn fmt(&self, f: &mut Formatter<JsFormatContext>) -> FormatResult<()> {
         match self.layout {
-            None | Some(ParameterLayout::Default) => {
+            None | Some(ParameterLayout::Default) | Some(ParameterLayout::NoParameters) => {
                 // The trailing separator is disallowed if the last element in the list is a rest parameter
                 let has_trailing_rest = match self.list.last() {
                     Some(elem) => matches!(
@@ -64,7 +64,7 @@ impl Format<JsFormatContext> for FormatJsAnyParameterList<'_> {
                 match self.list {
                     JsAnyParameterList::JsParameterList(list) => {
                         let entries = list
-                            .format_separated(JsSyntaxKind::COMMA)
+                            .format_separated(",")
                             .with_trailing_separator(trailing_separator)
                             .zip(list.iter());
 
@@ -74,7 +74,7 @@ impl Format<JsFormatContext> for FormatJsAnyParameterList<'_> {
                     }
                     JsAnyParameterList::JsConstructorParameterList(list) => {
                         let entries = list
-                            .format_separated(JsSyntaxKind::COMMA)
+                            .format_separated(",")
                             .with_trailing_separator(trailing_separator)
                             .zip(list.iter());
 
@@ -91,11 +91,11 @@ impl Format<JsFormatContext> for FormatJsAnyParameterList<'_> {
 
                 match self.list {
                     JsAnyParameterList::JsParameterList(list) => join.entries(
-                        list.format_separated(JsSyntaxKind::COMMA)
+                        list.format_separated(",")
                             .with_trailing_separator(TrailingSeparator::Omit),
                     ),
                     JsAnyParameterList::JsConstructorParameterList(list) => join.entries(
-                        list.format_separated(JsSyntaxKind::COMMA)
+                        list.format_separated(",")
                             .with_trailing_separator(TrailingSeparator::Omit),
                     ),
                 };
@@ -132,6 +132,13 @@ impl JsAnyParameterList {
         }
     }
 
+    pub fn is_empty(&self) -> bool {
+        match self {
+            JsAnyParameterList::JsParameterList(parameters) => parameters.is_empty(),
+            JsAnyParameterList::JsConstructorParameterList(parameters) => parameters.is_empty(),
+        }
+    }
+
     pub fn first(&self) -> Option<SyntaxResult<AnyParameter>> {
         Some(match self {
             JsAnyParameterList::JsParameterList(parameters) => {
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 bbeebef3dcc..8a7eab3548f 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
@@ -3,6 +3,7 @@ use crate::js::expressions::template_element::{AnyTemplateElement, TemplateEleme
 
 use crate::context::TabWidth;
 use crate::prelude::*;
+
 use rome_js_syntax::{
     JsAnyExpression, JsAnyLiteralExpression, JsAnyTemplateElement, JsLanguage,
     JsTemplateElementList, TsAnyTemplateElement, TsTemplateElementList,
@@ -28,7 +29,7 @@ pub(crate) enum AnyTemplateElementList {
 
 impl Format<JsFormatContext> for AnyTemplateElementList {
     fn fmt(&self, f: &mut Formatter<JsFormatContext>) -> FormatResult<()> {
-        let layout = if self.is_simple() {
+        let layout = if self.is_simple(f.comments()) {
             TemplateElementLayout::SingleLine
         } else {
             TemplateElementLayout::Fit
@@ -87,7 +88,7 @@ impl AnyTemplateElementList {
     /// Simple expressions are:
     /// * Identifiers: `this`, `a`
     /// * Members: `a.b`, `a[b]`, `a.b[c].d`, `a.b[5]`, `a.b["test"]`
-    fn is_simple(&self) -> bool {
+    fn is_simple(&self, comments: &JsComments) -> bool {
         match self {
             AnyTemplateElementList::JsTemplateElementList(list) => {
                 if list.is_empty() {
@@ -101,7 +102,9 @@ impl AnyTemplateElementList {
 
                 expression_elements.all(|expression_element| {
                     match expression_element.expression() {
-                        Ok(expression) => is_simple_member_expression(expression).unwrap_or(false),
+                        Ok(expression) => {
+                            is_simple_member_expression(expression, comments).unwrap_or(false)
+                        }
                         Err(_) => false,
                     }
                 })
@@ -142,11 +145,14 @@ declare_node_union! {
     AnyTemplateElementOrChunk = AnyTemplateElement | AnyTemplateChunkElement
 }
 
-fn is_simple_member_expression(expression: JsAnyExpression) -> SyntaxResult<bool> {
+fn is_simple_member_expression(
+    expression: JsAnyExpression,
+    comments: &JsComments,
+) -> SyntaxResult<bool> {
     let mut current = expression;
 
     loop {
-        if current.syntax().has_comments_direct() {
+        if comments.has_comments(current.syntax()) {
             return Ok(false);
         }
 
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 bc8894ac7b7..0e5778c814c 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
@@ -35,7 +35,7 @@ impl FormatRule<JsVariableDeclaratorList> for FormatJsVariableDeclaratorList {
         });
 
         let mut declarators = node.iter().zip(
-            node.format_separated(JsSyntaxKind::COMMA)
+            node.format_separated(",")
                 .with_trailing_separator(TrailingSeparator::Disallowed),
         );
 
@@ -44,7 +44,7 @@ impl FormatRule<JsVariableDeclaratorList> for FormatJsVariableDeclaratorList {
             None => return Err(FormatError::SyntaxError),
         };
 
-        if length == 1 && !first_declarator.syntax().has_leading_comments() {
+        if length == 1 && !f.comments().has_leading_comments(first_declarator.syntax()) {
             return write!(f, [format_first_declarator]);
         }
 
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 ea03e76178c..d0a7d9d9817 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
@@ -1,5 +1,5 @@
 use crate::prelude::*;
-use rome_formatter::write;
+use rome_formatter::{format_args, write};
 
 use crate::utils::FormatWithSemicolon;
 
@@ -24,15 +24,24 @@ impl FormatNodeRule<JsExportNamedClause> for FormatJsExportNamedClause {
                 write!(f, [type_token.format(), space()])?;
             }
 
-            write!(
-                f,
-                [format_delimited(
-                    l_curly_token.as_ref()?,
-                    &specifiers.format(),
-                    r_curly_token.as_ref()?
-                )
-                .soft_block_spaces()]
-            )
+            write!(f, [l_curly_token.format()])?;
+
+            if specifiers.is_empty() {
+                write!(
+                    f,
+                    [format_dangling_comments(node.syntax()).with_block_indent()]
+                )?;
+            } else {
+                write!(
+                    f,
+                    [group(&format_args![
+                        soft_line_indent_or_space(&specifiers.format()),
+                        soft_line_break_or_space(),
+                    ])]
+                )?;
+            }
+
+            write!(f, [r_curly_token.format()])
         });
 
         write!(
@@ -40,4 +49,13 @@ impl FormatNodeRule<JsExportNamedClause> for FormatJsExportNamedClause {
             [FormatWithSemicolon::new(&content, semicolon_token.as_ref())]
         )
     }
+
+    fn fmt_dangling_comments(
+        &self,
+        _: &JsExportNamedClause,
+        _: &mut JsFormatter,
+    ) -> FormatResult<()> {
+        // Handled as part of `fmt_fields`
+        Ok(())
+    }
 }
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 b8e0948cb2a..e7a967350bc 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
@@ -27,29 +27,27 @@ impl FormatNodeRule<JsExportNamedFromClause> for FormatJsExportNamedFromClause {
                 write!(f, [type_token.format(), space()])?;
             }
 
+            write!(f, [l_curly_token.format(),])?;
+
             if node_has_leading_newline(specifiers.syntax()) {
-                write!(
-                    f,
-                    [format_delimited(
-                        l_curly_token.as_ref()?,
-                        &specifiers.format(),
-                        r_curly_token.as_ref()?,
-                    )
-                    .block_indent()]
-                )?;
+                write!(f, [block_indent(&specifiers.format()),])?;
             } else {
                 write!(
                     f,
-                    [format_delimited(
-                        l_curly_token.as_ref()?,
-                        &specifiers.format(),
-                        r_curly_token.as_ref()?,
-                    )
-                    .soft_block_spaces()]
+                    [group(&soft_space_or_block_indent(&specifiers.format())),]
                 )?;
             };
 
-            write![f, [space(), from_token.format(), space(), source.format(),]]?;
+            write![
+                f,
+                [
+                    r_curly_token.format(),
+                    space(),
+                    from_token.format(),
+                    space(),
+                    source.format(),
+                ]
+            ]?;
 
             if let Some(assertion) = &assertion {
                 write!(f, [space(), assertion.format()])?;
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 a087824a2eb..6b13401cc45 100644
--- a/crates/rome_js_formatter/src/js/module/import_assertion.rs
+++ b/crates/rome_js_formatter/src/js/module/import_assertion.rs
@@ -16,14 +16,34 @@ impl FormatNodeRule<JsImportAssertion> for FormatJsImportAssertion {
             r_curly_token,
         } = node.as_fields();
 
-        write![f, [assert_token.format(), space()]]?;
+        write![f, [assert_token.format(), space(), l_curly_token.format()]]?;
 
-        write!(
-            f,
-            [
-                format_delimited(&l_curly_token?, &assertions.format(), &r_curly_token?,)
-                    .soft_block_spaces()
-            ]
-        )
+        if assertions.is_empty() {
+            let has_dangling = f.comments().has_dangling_comments(node.syntax());
+            write!(
+                f,
+                [
+                    has_dangling.then_some(space()),
+                    format_dangling_comments(node.syntax()).with_soft_block_indent(),
+                    has_dangling.then_some(space()),
+                ]
+            )?;
+        } else {
+            write!(
+                f,
+                [group(&soft_space_or_block_indent(&assertions.format()))]
+            )?;
+        }
+
+        write!(f, [r_curly_token.format()])
+    }
+
+    fn fmt_dangling_comments(
+        &self,
+        _: &JsImportAssertion,
+        _: &mut JsFormatter,
+    ) -> FormatResult<()> {
+        // Handled as part of `fmt_fields`
+        Ok(())
     }
 }
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 192f6a96ec1..8a58e4108ba 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
@@ -34,13 +34,30 @@ impl FormatNodeRule<JsImportAssertionEntry> for FormatJsImportAssertionEntry {
             }
         };
 
-        write![
+        write![f, [colon_token.format(), space()]]?;
+
+        if f.comments().has_dangling_comments(node.syntax()) {
+            write!(
+                f,
+                [space(), format_dangling_comments(node.syntax()), space()]
+            )?;
+        }
+
+        write!(
             f,
-            [
-                colon_token.format(),
-                space(),
-                FormatLiteralStringToken::new(&value_token?, StringLiteralParentKind::Expression),
-            ]
-        ]
+            [FormatLiteralStringToken::new(
+                &value_token?,
+                StringLiteralParentKind::Expression
+            )]
+        )
+    }
+
+    fn fmt_dangling_comments(
+        &self,
+        _: &JsImportAssertionEntry,
+        _: &mut JsFormatter,
+    ) -> FormatResult<()> {
+        // Handled inside `fmt_fields`
+        Ok(())
     }
 }
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 8f5473ba5d5..9778e483b40 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
@@ -15,12 +15,29 @@ impl FormatNodeRule<JsNamedImportSpecifiers> for FormatJsNamedImportSpecifiers {
             r_curly_token,
         } = node.as_fields();
 
-        write!(
-            f,
-            [
-                format_delimited(&l_curly_token?, &specifiers.format(), &r_curly_token?,)
-                    .soft_block_spaces()
-            ]
-        )
+        write!(f, [l_curly_token.format()])?;
+
+        if specifiers.is_empty() {
+            write!(
+                f,
+                [format_dangling_comments(node.syntax()).with_soft_block_indent()]
+            )?;
+        } else {
+            write!(
+                f,
+                [group(&soft_space_or_block_indent(&specifiers.format()))]
+            )?;
+        }
+
+        write!(f, [r_curly_token.format()])
+    }
+
+    fn fmt_dangling_comments(
+        &self,
+        _: &JsNamedImportSpecifiers,
+        _: &mut JsFormatter,
+    ) -> FormatResult<()> {
+        // Handled inside of `fmt_fields`
+        Ok(())
     }
 }
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 3b1ad2389d2..6938837b6ca 100644
--- a/crates/rome_js_formatter/src/js/statements/block_statement.rs
+++ b/crates/rome_js_formatter/src/js/statements/block_statement.rs
@@ -1,7 +1,7 @@
 use crate::prelude::*;
-use rome_formatter::{write, Buffer, Comments, CstFormatContext};
+use rome_formatter::{write, Buffer, CstFormatContext};
+use rome_js_syntax::JsBlockStatement;
 use rome_js_syntax::{JsAnyStatement, JsEmptyStatement};
-use rome_js_syntax::{JsBlockStatement, JsLanguage};
 
 use rome_js_syntax::JsBlockStatementFields;
 use rome_js_syntax::JsSyntaxKind;
@@ -18,7 +18,14 @@ impl FormatNodeRule<JsBlockStatement> for FormatJsBlockStatement {
             r_curly_token,
         } = node.as_fields();
 
-        if is_non_collapsable_empty_block(node, f.context().comments()) {
+        write!(f, [l_curly_token.format()])?;
+
+        let r_curly_token = r_curly_token?;
+
+        let comments = f.context().comments();
+        if is_empty_block(node, comments) {
+            let has_dangling_comments = comments.has_dangling_comments(node.syntax());
+
             for stmt in statements
                 .iter()
                 .filter_map(|stmt| JsEmptyStatement::cast(stmt.into_syntax()))
@@ -26,44 +33,28 @@ impl FormatNodeRule<JsBlockStatement> for FormatJsBlockStatement {
                 f.state_mut().track_token(&stmt.semicolon_token()?)
             }
 
-            write!(
-                f,
-                [
-                    l_curly_token.format(),
-                    hard_line_break(),
-                    r_curly_token.format()
-                ]
-            )
+            if has_dangling_comments {
+                write!(
+                    f,
+                    [format_dangling_comments(node.syntax()).with_block_indent()]
+                )?;
+            } else if is_non_collapsible(node) {
+                write!(f, [hard_line_break()])?;
+            }
         } else {
-            write!(
-                f,
-                [
-                    format_delimited(&l_curly_token?, &statements.format(), &r_curly_token?)
-                        .block_indent()
-                ]
-            )
+            write!(f, [block_indent(&statements.format())])?;
         }
+
+        write!(f, [r_curly_token.format()])
     }
-}
 
-// Formatting of curly braces for an:
-// * empty block: same line `{}`,
-// * empty block that is the 'cons' or 'alt' of an if statement: two lines `{\n}`
-// * non empty block: put each stmt on its own line: `{\nstmt1;\nstmt2;\n}`
-// * non empty block with comments (trailing comments on {, or leading comments on })
-fn is_non_collapsable_empty_block(
-    block: &JsBlockStatement,
-    suppressions: &Comments<JsLanguage>,
-) -> bool {
-    if block
-        .l_curly_token()
-        .map_or_else(|_| false, |token| token.has_trailing_comments())
-        || block
-            .r_curly_token()
-            .map_or_else(|_| false, |token| token.has_leading_comments())
-    {
-        return false;
+    fn fmt_dangling_comments(&self, _: &JsBlockStatement, _: &mut JsFormatter) -> FormatResult<()> {
+        // Formatted inside of `fmt_fields`
+        Ok(())
     }
+}
+
+fn is_empty_block(block: &JsBlockStatement, comments: &JsComments) -> bool {
     // add extra branch to avoid formatting the same code twice and generating different code,
     // here is an example:
     // ```js
@@ -89,15 +80,20 @@ fn is_non_collapsable_empty_block(
     // } finally {
     // }
     // ```
-    if !block.statements().is_empty()
-        && block.statements().iter().any(|s| {
-            !matches!(s, JsAnyStatement::JsEmptyStatement(_))
-                || s.syntax().has_comments_direct()
-                || suppressions.is_suppressed(s.syntax())
+    block.statements().is_empty()
+        || block.statements().iter().all(|s| {
+            matches!(s, JsAnyStatement::JsEmptyStatement(_))
+                && !comments.has_comments(s.syntax())
+                && !comments.is_suppressed(s.syntax())
         })
-    {
-        return false;
-    }
+}
+
+// Formatting of curly braces for an:
+// * empty block: same line `{}`,
+// * empty block that is the 'cons' or 'alt' of an if statement: two lines `{\n}`
+// * non empty block: put each stmt on its own line: `{\nstmt1;\nstmt2;\n}`
+// * non empty block with comments (trailing comments on {, or leading comments on })
+fn is_non_collapsible(block: &JsBlockStatement) -> bool {
     // reference https://github.com/prettier/prettier/blob/b188c905cfaeb238a122b4a95c230da83f2f3226/src/language-js/print/block.js#L19
     let parent = block.syntax().parent();
     match parent.clone().map(|p| p.kind()) {
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 81d50009f5f..d4b59c4e990 100644
--- a/crates/rome_js_formatter/src/js/statements/break_statement.rs
+++ b/crates/rome_js_formatter/src/js/statements/break_statement.rs
@@ -20,7 +20,7 @@ impl FormatNodeRule<JsBreakStatement> for FormatJsBreakStatement {
         write!(
             f,
             [FormatWithSemicolon::new(
-                &format_with(|f| {
+                &format_with(|f: &mut JsFormatter| {
                     write!(f, [break_token.format()])?;
 
                     if let Some(label) = &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 28f8c01a193..9d179d467b2 100644
--- a/crates/rome_js_formatter/src/js/statements/continue_statement.rs
+++ b/crates/rome_js_formatter/src/js/statements/continue_statement.rs
@@ -20,7 +20,7 @@ impl FormatNodeRule<JsContinueStatement> for FormatJsContinueStatement {
         write!(
             f,
             [FormatWithSemicolon::new(
-                &format_with(|f| {
+                &format_with(|f: &mut JsFormatter| {
                     write!(f, [continue_token.format()])?;
 
                     if let Some(label) = &label_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 738c5006423..eb7ee56b240 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
@@ -44,8 +44,9 @@ impl FormatNodeRule<JsDoWhileStatement> for FormatJsDoWhileStatement {
                 [
                     while_token.format(),
                     space(),
-                    format_delimited(&l_paren_token, &test.format(), &r_paren_token)
-                        .soft_block_indent(),
+                    l_paren_token.format(),
+                    group(&soft_block_indent(&test.format())),
+                    r_paren_token.format()
                 ]
             )
         });
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 0ccd0f19f85..be1eed5e4c0 100644
--- a/crates/rome_js_formatter/src/js/statements/expression_statement.rs
+++ b/crates/rome_js_formatter/src/js/statements/expression_statement.rs
@@ -1,5 +1,5 @@
 use crate::prelude::*;
-use rome_formatter::write;
+use rome_formatter::{write, CstFormatContext};
 
 use crate::utils::FormatWithSemicolon;
 
@@ -16,12 +16,29 @@ impl FormatNodeRule<JsExpressionStatement> for FormatJsExpressionStatement {
             semicolon_token,
         } = node.as_fields();
 
+        let has_dangling_comments = f.context().comments().has_dangling_comments(node.syntax());
+
         write!(
             f,
             [FormatWithSemicolon::new(
                 &expression.format(),
                 semicolon_token.as_ref()
             )]
-        )
+        )?;
+
+        if has_dangling_comments {
+            write!(f, [space(), format_dangling_comments(node.syntax())])?;
+        }
+
+        Ok(())
+    }
+
+    fn fmt_dangling_comments(
+        &self,
+        _: &JsExpressionStatement,
+        _: &mut JsFormatter,
+    ) -> FormatResult<()> {
+        // Formatted inside of `fmt_fields`
+        Ok(())
     }
 }
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 72451c761b7..bc7bcee993b 100644
--- a/crates/rome_js_formatter/src/js/statements/for_statement.rs
+++ b/crates/rome_js_formatter/src/js/statements/for_statement.rs
@@ -1,5 +1,5 @@
 use crate::prelude::*;
-use rome_formatter::{format_args, write};
+use rome_formatter::{format_args, write, CstFormatContext};
 
 use crate::utils::FormatStatementBody;
 use rome_js_syntax::JsForStatement;
@@ -23,9 +23,24 @@ impl FormatNodeRule<JsForStatement> for FormatJsForStatement {
         } = node.as_fields();
 
         let body = body?;
+        let l_paren_token = l_paren_token?;
 
         let format_body = FormatStatementBody::new(&body);
 
+        // Move dangling trivia between the `for /* this */ (` to the top of the `for` and
+        // add a line break after.
+        let comments = f.context().comments();
+        let dangling_comments = comments.dangling_comments(node.syntax());
+        if !dangling_comments.is_empty() {
+            write!(
+                f,
+                [
+                    format_dangling_comments(node.syntax()),
+                    soft_line_break_or_space()
+                ]
+            )?;
+        }
+
         if initializer.is_none() && test.is_none() && update.is_none() {
             return write!(
                 f,
@@ -65,4 +80,9 @@ impl FormatNodeRule<JsForStatement> for FormatJsForStatement {
 
         write!(f, [group(&format_inner)])
     }
+
+    fn fmt_dangling_comments(&self, _: &JsForStatement, _: &mut JsFormatter) -> FormatResult<()> {
+        // Formatted inside of `fmt_fields`
+        Ok(())
+    }
 }
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 9f553d9b3e9..dd6bd5010d0 100644
--- a/crates/rome_js_formatter/src/js/statements/if_statement.rs
+++ b/crates/rome_js_formatter/src/js/statements/if_statement.rs
@@ -1,5 +1,5 @@
 use crate::prelude::*;
-use rome_formatter::{format_args, write};
+use rome_formatter::{format_args, write, CstFormatContext};
 
 use crate::utils::FormatStatementBody;
 use rome_js_syntax::JsIfStatement;
@@ -30,14 +30,29 @@ impl FormatNodeRule<JsIfStatement> for FormatJsIfStatement {
             [group(&format_args![
                 if_token.format(),
                 space(),
-                format_delimited(&l_paren_token, &test.format(), &r_paren_token)
-                    .soft_block_indent(),
+                l_paren_token.format(),
+                group(&soft_block_indent(&test.format())),
+                r_paren_token.format(),
                 FormatStatementBody::new(&consequent),
             ]),]
         )?;
 
         if let Some(else_clause) = else_clause {
-            let else_on_same_line = matches!(consequent, JsBlockStatement(_));
+            let comments = f.context().comments();
+            let dangling_comments = comments.dangling_comments(node.syntax());
+            let dangling_line_comment = dangling_comments
+                .last()
+                .map_or(false, |comment| comment.kind().is_line());
+            let has_dangling_comments = !dangling_comments.is_empty();
+
+            let trailing_line_comment = comments
+                .trailing_comments(consequent.syntax())
+                .iter()
+                .any(|comment| comment.kind().is_line());
+
+            let else_on_same_line = matches!(consequent, JsBlockStatement(_))
+                && !trailing_line_comment
+                && !dangling_line_comment;
 
             if else_on_same_line {
                 write!(f, [space()])?;
@@ -45,9 +60,24 @@ impl FormatNodeRule<JsIfStatement> for FormatJsIfStatement {
                 write!(f, [hard_line_break()])?;
             }
 
+            if has_dangling_comments {
+                write!(f, [format_dangling_comments(node.syntax())])?;
+
+                if trailing_line_comment || dangling_line_comment {
+                    write!(f, [hard_line_break()])?
+                } else {
+                    write!(f, [space()])?;
+                }
+            }
+
             write!(f, [else_clause.format()])?;
         }
 
         Ok(())
     }
+
+    fn fmt_dangling_comments(&self, _: &JsIfStatement, _: &mut JsFormatter) -> FormatResult<()> {
+        // Formatted inside of `fmt_fields`
+        Ok(())
+    }
 }
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 1d3c94fed4c..8ef898b4a2f 100644
--- a/crates/rome_js_formatter/src/js/statements/labeled_statement.rs
+++ b/crates/rome_js_formatter/src/js/statements/labeled_statement.rs
@@ -1,8 +1,8 @@
 use crate::prelude::*;
 use rome_formatter::write;
 
+use rome_js_syntax::JsLabeledStatementFields;
 use rome_js_syntax::{JsAnyStatement, JsLabeledStatement};
-use rome_js_syntax::{JsLabeledStatementFields, JsSyntaxKind};
 
 #[derive(Debug, Clone, Default)]
 pub struct FormatJsLabeledStatement;
@@ -20,10 +20,7 @@ impl FormatNodeRule<JsLabeledStatement> for FormatJsLabeledStatement {
         match body? {
             JsAnyStatement::JsEmptyStatement(empty) => {
                 // If the body is an empty statement, force semicolon insertion
-                write!(
-                    f,
-                    [empty.format(), format_inserted(JsSyntaxKind::SEMICOLON)]
-                )
+                write!(f, [empty.format(), text(";")])
             }
             body => {
                 write!(f, [space(), body.format()])
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 1493da0fb9e..33b9b171361 100644
--- a/crates/rome_js_formatter/src/js/statements/return_statement.rs
+++ b/crates/rome_js_formatter/src/js/statements/return_statement.rs
@@ -1,64 +1,120 @@
 use crate::prelude::*;
-use crate::utils::{FormatWithSemicolon, JsAnyBinaryLikeExpression};
+use crate::utils::{FormatWithSemicolon, JsAnyBinaryLikeExpression, JsAnyBinaryLikeLeftExpression};
 
-use rome_formatter::{format_args, write};
+use rome_formatter::{format_args, write, CstFormatContext};
 
+use crate::parentheses::get_expression_left_side;
 use rome_js_syntax::{
-    JsAnyExpression, JsReturnStatement, JsReturnStatementFields, JsSequenceExpression, JsSyntaxKind,
+    JsAnyExpression, JsReturnStatement, JsSequenceExpression, JsSyntaxToken, JsThrowStatement,
 };
+use rome_rowan::{declare_node_union, SyntaxResult};
 
 #[derive(Debug, Clone, Default)]
 pub struct FormatJsReturnStatement;
 
 impl FormatNodeRule<JsReturnStatement> for FormatJsReturnStatement {
     fn fmt_fields(&self, node: &JsReturnStatement, f: &mut JsFormatter) -> FormatResult<()> {
-        let JsReturnStatementFields {
-            return_token,
-            argument,
-            semicolon_token,
-        } = node.as_fields();
+        JsAnyStatementWithArgument::from(node.clone()).fmt(f)
+    }
+
+    fn fmt_dangling_comments(
+        &self,
+        _: &JsReturnStatement,
+        _: &mut JsFormatter,
+    ) -> FormatResult<()> {
+        // Formatted inside of `JsAnyStatementWithArgument`
+        Ok(())
+    }
+}
+
+declare_node_union! {
+    pub(super) JsAnyStatementWithArgument = JsThrowStatement | JsReturnStatement
+}
+
+impl Format<JsFormatContext> for JsAnyStatementWithArgument {
+    fn fmt(&self, f: &mut Formatter<JsFormatContext>) -> FormatResult<()> {
+        write!(f, [self.operation_token().format()])?;
+
+        let argument = self.argument()?;
+
+        if let Some(semicolon) = self.semicolon_token() {
+            if let Some(argument) = argument {
+                write!(f, [space(), FormatReturnOrThrowArgument(&argument)])?;
+            }
+
+            let comments = f.context().comments();
+            let has_dangling_comments = comments.has_dangling_comments(self.syntax());
+
+            let is_last_comment_line = comments
+                .trailing_comments(self.syntax())
+                .last()
+                .or_else(|| comments.dangling_comments(self.syntax()).last())
+                .map_or(false, |comment| comment.kind().is_line());
+
+            if is_last_comment_line {
+                write!(f, [semicolon.format()])?;
+            }
 
-        let format_inner = format_with(|f| {
-            write!(f, [return_token.format()])?;
+            if has_dangling_comments {
+                write!(f, [space(), format_dangling_comments(self.syntax())])?;
+            }
 
-            if let Some(argument) = &argument {
-                write!(f, [space(), FormatReturnOrThrowArgument(argument)])?;
+            if !is_last_comment_line {
+                write!(f, [semicolon.format()])?;
             }
 
             Ok(())
-        });
-
-        write!(
-            f,
-            [FormatWithSemicolon::new(
-                &format_inner,
-                semicolon_token.as_ref()
-            )]
-        )
+        } else {
+            write!(
+                f,
+                [FormatWithSemicolon::new(
+                    &format_with(|f| {
+                        if let Some(argument) = &argument {
+                            write!(f, [space(), FormatReturnOrThrowArgument(argument)])?;
+                        }
+
+                        Ok(())
+                    }),
+                    None
+                )]
+            )
+        }
     }
 }
 
-pub(super) struct FormatReturnOrThrowArgument<'a>(&'a JsAnyExpression);
+impl JsAnyStatementWithArgument {
+    fn operation_token(&self) -> SyntaxResult<JsSyntaxToken> {
+        match self {
+            JsAnyStatementWithArgument::JsThrowStatement(throw) => throw.throw_token(),
+            JsAnyStatementWithArgument::JsReturnStatement(ret) => ret.return_token(),
+        }
+    }
 
-impl<'a> FormatReturnOrThrowArgument<'a> {
-    pub fn new(argument: &'a JsAnyExpression) -> Self {
-        Self(argument)
+    fn argument(&self) -> SyntaxResult<Option<JsAnyExpression>> {
+        match self {
+            JsAnyStatementWithArgument::JsThrowStatement(throw) => throw.argument().map(Some),
+            JsAnyStatementWithArgument::JsReturnStatement(ret) => Ok(ret.argument()),
+        }
+    }
+
+    fn semicolon_token(&self) -> Option<JsSyntaxToken> {
+        match self {
+            JsAnyStatementWithArgument::JsThrowStatement(throw) => throw.semicolon_token(),
+            JsAnyStatementWithArgument::JsReturnStatement(ret) => ret.semicolon_token(),
+        }
     }
 }
 
+pub(super) struct FormatReturnOrThrowArgument<'a>(&'a JsAnyExpression);
+
 impl Format<JsFormatContext> for FormatReturnOrThrowArgument<'_> {
     fn fmt(&self, f: &mut Formatter<JsFormatContext>) -> FormatResult<()> {
         let argument = self.0;
 
-        if has_argument_leading_comments(argument) {
-            write!(
-                f,
-                [
-                    format_inserted(JsSyntaxKind::L_PAREN),
-                    &block_indent(&argument.format()),
-                    format_inserted(JsSyntaxKind::R_PAREN)
-                ]
-            )
+        if has_argument_leading_comments(argument, f.context().comments())
+            && !matches!(argument, JsAnyExpression::JsxTagExpression(_))
+        {
+            write!(f, [text("("), &block_indent(&argument.format()), text(")")])
         } else if is_binary_or_sequence_argument(argument) {
             write!(
                 f,
@@ -80,13 +136,25 @@ impl Format<JsFormatContext> for FormatReturnOrThrowArgument<'_> {
 ///
 /// Traversing the left nodes is necessary in case the first node is parenthesized because
 /// parentheses will be removed (and be re-added by the return statement, but only if the argument breaks)
-fn has_argument_leading_comments(argument: &JsAnyExpression) -> bool {
-    if matches!(argument, JsAnyExpression::JsxTagExpression(_)) {
-        // JSX formatting takes care of adding parens
-        return false;
+fn has_argument_leading_comments(argument: &JsAnyExpression, comments: &JsComments) -> bool {
+    let mut current: Option<JsAnyBinaryLikeLeftExpression> = Some(argument.clone().into());
+
+    while let Some(expression) = current {
+        if comments.has_leading_own_line_comment(expression.syntax()) {
+            return true;
+        }
+
+        match expression {
+            JsAnyBinaryLikeLeftExpression::JsAnyExpression(expression) => {
+                current = get_expression_left_side(&expression);
+            }
+            JsAnyBinaryLikeLeftExpression::JsPrivateName(_) => {
+                break;
+            }
+        }
     }
 
-    argument.syntax().has_leading_comments()
+    false
 }
 
 fn is_binary_or_sequence_argument(argument: &JsAnyExpression) -> bool {
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 9ddb27381aa..3c62883fc4d 100644
--- a/crates/rome_js_formatter/src/js/statements/switch_statement.rs
+++ b/crates/rome_js_formatter/src/js/statements/switch_statement.rs
@@ -34,10 +34,13 @@ impl FormatNodeRule<JsSwitchStatement> for FormatJsSwitchStatement {
             [
                 switch_token.format(),
                 space(),
-                format_delimited(&l_paren_token?, &discriminant.format(), &r_paren_token?,)
-                    .soft_block_indent(),
+                l_paren_token.format(),
+                group(&soft_block_indent(&discriminant.format())),
+                r_paren_token.format(),
                 space(),
-                format_delimited(&l_curly_token?, &format_cases, &r_curly_token?).block_indent()
+                l_curly_token.format(),
+                block_indent(&format_cases),
+                r_curly_token.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 23253d0588b..fe648980a87 100644
--- a/crates/rome_js_formatter/src/js/statements/throw_statement.rs
+++ b/crates/rome_js_formatter/src/js/statements/throw_statement.rs
@@ -1,33 +1,18 @@
 use crate::prelude::*;
-use rome_formatter::{format_args, write};
 
-use crate::utils::FormatWithSemicolon;
-
-use crate::js::statements::return_statement::FormatReturnOrThrowArgument;
+use crate::js::statements::return_statement::JsAnyStatementWithArgument;
 use rome_js_syntax::JsThrowStatement;
-use rome_js_syntax::JsThrowStatementFields;
 
 #[derive(Debug, Clone, Default)]
 pub struct FormatJsThrowStatement;
 
 impl FormatNodeRule<JsThrowStatement> for FormatJsThrowStatement {
     fn fmt_fields(&self, node: &JsThrowStatement, f: &mut JsFormatter) -> FormatResult<()> {
-        let JsThrowStatementFields {
-            throw_token,
-            argument,
-            semicolon_token,
-        } = node.as_fields();
+        JsAnyStatementWithArgument::from(node.clone()).fmt(f)
+    }
 
-        write!(
-            f,
-            [FormatWithSemicolon::new(
-                &format_args![
-                    throw_token.format(),
-                    space(),
-                    FormatReturnOrThrowArgument::new(&argument?)
-                ],
-                semicolon_token.as_ref()
-            )]
-        )
+    fn fmt_dangling_comments(&self, _: &JsThrowStatement, _: &mut JsFormatter) -> FormatResult<()> {
+        // Formatted inside of `JsAnyStatementWithArgument`
+        Ok(())
     }
 }
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 e7dd093423a..585ef070b8b 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
@@ -16,7 +16,7 @@ impl FormatNodeRule<JsTryFinallyStatement> for FormatJsTryFinallyStatement {
             finally_clause,
         } = node.as_fields();
 
-        write![f, [try_token.format(), space(), body.format(),]]?;
+        write![f, [try_token.format(), space(), body.format()]]?;
 
         if let Some(catch_clause) = catch_clause {
             write!(f, [space(), catch_clause.format()])?;
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 89ca7ab8a33..d7ac842347f 100644
--- a/crates/rome_js_formatter/src/js/statements/while_statement.rs
+++ b/crates/rome_js_formatter/src/js/statements/while_statement.rs
@@ -23,8 +23,9 @@ impl FormatNodeRule<JsWhileStatement> for FormatJsWhileStatement {
             [group(&format_args![
                 while_token.format(),
                 space(),
-                format_delimited(&l_paren_token?, &test.format(), &r_paren_token?)
-                    .soft_block_indent(),
+                l_paren_token.format(),
+                group(&soft_block_indent(&test.format())),
+                r_paren_token.format(),
                 FormatStatementBody::new(&body?)
             ])]
         )
diff --git a/crates/rome_js_formatter/src/js/unknown/unknown.rs b/crates/rome_js_formatter/src/js/unknown/unknown.rs
index 70fd4e21471..34be2b920d6 100644
--- a/crates/rome_js_formatter/src/js/unknown/unknown.rs
+++ b/crates/rome_js_formatter/src/js/unknown/unknown.rs
@@ -1,13 +1,7 @@
-use crate::prelude::*;
-
+use crate::FormatUnknownNodeRule;
 use rome_js_syntax::JsUnknown;
-use rome_rowan::AstNode;
 
 #[derive(Debug, Clone, Default)]
 pub struct FormatJsUnknown;
 
-impl FormatNodeRule<JsUnknown> for FormatJsUnknown {
-    fn fmt_fields(&self, node: &JsUnknown, formatter: &mut JsFormatter) -> FormatResult<()> {
-        format_unknown_node(node.syntax()).fmt(formatter)
-    }
-}
+impl FormatUnknownNodeRule<JsUnknown> for FormatJsUnknown {}
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 4cf01d7f3c6..d27f81c42fc 100644
--- a/crates/rome_js_formatter/src/js/unknown/unknown_assignment.rs
+++ b/crates/rome_js_formatter/src/js/unknown/unknown_assignment.rs
@@ -1,25 +1,11 @@
-use crate::prelude::*;
-
 use crate::parentheses::NeedsParentheses;
+use crate::FormatUnknownNodeRule;
 use rome_js_syntax::{JsSyntaxNode, JsUnknownAssignment};
-use rome_rowan::AstNode;
 
 #[derive(Debug, Clone, Default)]
 pub struct FormatJsUnknownAssignment;
 
-impl FormatNodeRule<JsUnknownAssignment> for FormatJsUnknownAssignment {
-    fn fmt_fields(
-        &self,
-        node: &JsUnknownAssignment,
-        formatter: &mut JsFormatter,
-    ) -> FormatResult<()> {
-        format_unknown_node(node.syntax()).fmt(formatter)
-    }
-
-    fn needs_parentheses(&self, item: &JsUnknownAssignment) -> bool {
-        item.needs_parentheses()
-    }
-}
+impl FormatUnknownNodeRule<JsUnknownAssignment> for FormatJsUnknownAssignment {}
 
 impl NeedsParentheses for JsUnknownAssignment {
     #[inline]
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 31cb8a2db66..d1aab009f9f 100644
--- a/crates/rome_js_formatter/src/js/unknown/unknown_binding.rs
+++ b/crates/rome_js_formatter/src/js/unknown/unknown_binding.rs
@@ -1,13 +1,7 @@
-use crate::prelude::*;
-
+use crate::FormatUnknownNodeRule;
 use rome_js_syntax::JsUnknownBinding;
-use rome_rowan::AstNode;
 
 #[derive(Debug, Clone, Default)]
 pub struct FormatJsUnknownBinding;
 
-impl FormatNodeRule<JsUnknownBinding> for FormatJsUnknownBinding {
-    fn fmt_fields(&self, node: &JsUnknownBinding, formatter: &mut JsFormatter) -> FormatResult<()> {
-        format_unknown_node(node.syntax()).fmt(formatter)
-    }
-}
+impl FormatUnknownNodeRule<JsUnknownBinding> for FormatJsUnknownBinding {}
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 fa8b3386e7d..2bac8d81b75 100644
--- a/crates/rome_js_formatter/src/js/unknown/unknown_expression.rs
+++ b/crates/rome_js_formatter/src/js/unknown/unknown_expression.rs
@@ -1,25 +1,11 @@
-use crate::prelude::*;
-
 use crate::parentheses::NeedsParentheses;
+use crate::FormatUnknownNodeRule;
 use rome_js_syntax::{JsSyntaxNode, JsUnknownExpression};
-use rome_rowan::AstNode;
 
 #[derive(Debug, Clone, Default)]
 pub struct FormatJsUnknownExpression;
 
-impl FormatNodeRule<JsUnknownExpression> for FormatJsUnknownExpression {
-    fn fmt_fields(
-        &self,
-        node: &JsUnknownExpression,
-        formatter: &mut JsFormatter,
-    ) -> FormatResult<()> {
-        format_unknown_node(node.syntax()).fmt(formatter)
-    }
-
-    fn needs_parentheses(&self, item: &JsUnknownExpression) -> bool {
-        item.needs_parentheses()
-    }
-}
+impl FormatUnknownNodeRule<JsUnknownExpression> for FormatJsUnknownExpression {}
 
 impl NeedsParentheses for JsUnknownExpression {
     #[inline]
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 f2f9fe7af37..5f9252aea7d 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
@@ -1,17 +1,7 @@
-use crate::prelude::*;
-
+use crate::FormatUnknownNodeRule;
 use rome_js_syntax::JsUnknownImportAssertionEntry;
-use rome_rowan::AstNode;
 
 #[derive(Debug, Clone, Default)]
 pub struct FormatJsUnknownImportAssertionEntry;
 
-impl FormatNodeRule<JsUnknownImportAssertionEntry> for FormatJsUnknownImportAssertionEntry {
-    fn fmt_fields(
-        &self,
-        node: &JsUnknownImportAssertionEntry,
-        formatter: &mut JsFormatter,
-    ) -> FormatResult<()> {
-        format_unknown_node(node.syntax()).fmt(formatter)
-    }
-}
+impl FormatUnknownNodeRule<JsUnknownImportAssertionEntry> for FormatJsUnknownImportAssertionEntry {}
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 0ef6be8648e..ab2a80f6927 100644
--- a/crates/rome_js_formatter/src/js/unknown/unknown_member.rs
+++ b/crates/rome_js_formatter/src/js/unknown/unknown_member.rs
@@ -1,13 +1,7 @@
-use crate::prelude::*;
-
+use crate::FormatUnknownNodeRule;
 use rome_js_syntax::JsUnknownMember;
-use rome_rowan::AstNode;
 
 #[derive(Debug, Clone, Default)]
 pub struct FormatJsUnknownMember;
 
-impl FormatNodeRule<JsUnknownMember> for FormatJsUnknownMember {
-    fn fmt_fields(&self, node: &JsUnknownMember, formatter: &mut JsFormatter) -> FormatResult<()> {
-        format_unknown_node(node.syntax()).fmt(formatter)
-    }
-}
+impl FormatUnknownNodeRule<JsUnknownMember> for FormatJsUnknownMember {}
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 da60c89758b..0f7c58ff566 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
@@ -1,17 +1,7 @@
-use crate::prelude::*;
-
+use crate::FormatUnknownNodeRule;
 use rome_js_syntax::JsUnknownNamedImportSpecifier;
-use rome_rowan::AstNode;
 
 #[derive(Debug, Clone, Default)]
 pub struct FormatJsUnknownNamedImportSpecifier;
 
-impl FormatNodeRule<JsUnknownNamedImportSpecifier> for FormatJsUnknownNamedImportSpecifier {
-    fn fmt_fields(
-        &self,
-        node: &JsUnknownNamedImportSpecifier,
-        formatter: &mut JsFormatter,
-    ) -> FormatResult<()> {
-        format_unknown_node(node.syntax()).fmt(formatter)
-    }
-}
+impl FormatUnknownNodeRule<JsUnknownNamedImportSpecifier> for FormatJsUnknownNamedImportSpecifier {}
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 bb7f282ccbf..b05189cb6c2 100644
--- a/crates/rome_js_formatter/src/js/unknown/unknown_parameter.rs
+++ b/crates/rome_js_formatter/src/js/unknown/unknown_parameter.rs
@@ -1,17 +1,7 @@
-use crate::prelude::*;
-
+use crate::FormatUnknownNodeRule;
 use rome_js_syntax::JsUnknownParameter;
-use rome_rowan::AstNode;
 
 #[derive(Debug, Clone, Default)]
 pub struct FormatJsUnknownParameter;
 
-impl FormatNodeRule<JsUnknownParameter> for FormatJsUnknownParameter {
-    fn fmt_fields(
-        &self,
-        node: &JsUnknownParameter,
-        formatter: &mut JsFormatter,
-    ) -> FormatResult<()> {
-        format_unknown_node(node.syntax()).fmt(formatter)
-    }
-}
+impl FormatUnknownNodeRule<JsUnknownParameter> for FormatJsUnknownParameter {}
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 996609ac4a3..dff7a4aa581 100644
--- a/crates/rome_js_formatter/src/js/unknown/unknown_statement.rs
+++ b/crates/rome_js_formatter/src/js/unknown/unknown_statement.rs
@@ -1,17 +1,7 @@
-use crate::prelude::*;
-
+use crate::FormatUnknownNodeRule;
 use rome_js_syntax::JsUnknownStatement;
-use rome_rowan::AstNode;
 
 #[derive(Debug, Clone, Default)]
 pub struct FormatJsUnknownStatement;
 
-impl FormatNodeRule<JsUnknownStatement> for FormatJsUnknownStatement {
-    fn fmt_fields(
-        &self,
-        node: &JsUnknownStatement,
-        formatter: &mut JsFormatter,
-    ) -> FormatResult<()> {
-        format_unknown_node(node.syntax()).fmt(formatter)
-    }
-}
+impl FormatUnknownNodeRule<JsUnknownStatement> for FormatJsUnknownStatement {}
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 6563f02ea82..8617905210e 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
@@ -1,6 +1,6 @@
 use crate::prelude::*;
 
-use rome_formatter::{format_args, write};
+use rome_formatter::{format_args, write, CstFormatContext};
 use rome_js_syntax::{
     JsAnyExpression, JsxAnyTag, JsxExpressionAttributeValue, JsxExpressionAttributeValueFields,
 };
@@ -22,7 +22,7 @@ impl FormatNodeRule<JsxExpressionAttributeValue> for FormatJsxExpressionAttribut
 
         let expression = expression?;
 
-        let should_inline = should_inline_jsx_expression(&expression);
+        let should_inline = should_inline_jsx_expression(&expression, f.context().comments());
 
         if should_inline {
             write!(
@@ -74,10 +74,13 @@ impl FormatNodeRule<JsxExpressionAttributeValue> for FormatJsxExpressionAttribut
 ///       ]
 ///     } />
 /// ```
-pub(crate) fn should_inline_jsx_expression(expression: &JsAnyExpression) -> bool {
+pub(crate) fn should_inline_jsx_expression(
+    expression: &JsAnyExpression,
+    comments: &JsComments,
+) -> bool {
     use JsAnyExpression::*;
 
-    if expression.syntax().has_comments_direct() {
+    if comments.has_comments(expression.syntax()) {
         return false;
     }
 
@@ -94,7 +97,7 @@ pub(crate) fn should_inline_jsx_expression(expression: &JsAnyExpression) -> bool
         JsAwaitExpression(await_expression) => match await_expression.argument() {
             Ok(JsxTagExpression(argument)) => {
                 matches!(argument.tag(), Ok(JsxAnyTag::JsxElement(_)))
-                    && should_inline_jsx_expression(&argument.into())
+                    && should_inline_jsx_expression(&argument.into(), comments)
             }
             _ => false,
         },
diff --git a/crates/rome_js_formatter/src/jsx/attribute/spread_attribute.rs b/crates/rome_js_formatter/src/jsx/attribute/spread_attribute.rs
index 4b3972b227b..d9001e6857e 100644
--- a/crates/rome_js_formatter/src/jsx/attribute/spread_attribute.rs
+++ b/crates/rome_js_formatter/src/jsx/attribute/spread_attribute.rs
@@ -15,14 +15,20 @@ impl FormatNodeRule<JsxSpreadAttribute> for FormatJsxSpreadAttribute {
             r_curly_token,
         } = node.as_fields();
 
-        write![
-            f,
-            [
-                l_curly_token.format(),
-                dotdotdot_token.format(),
-                argument.format(),
-                r_curly_token.format(),
-            ]
-        ]
+        let argument = argument?;
+        let format_inner =
+            format_with(|f| write!(f, [dotdotdot_token.format(), argument.format(),]));
+
+        write!(f, [l_curly_token.format()])?;
+
+        if f.comments().has_comments(argument.syntax())
+            && !f.comments().is_suppressed(argument.syntax())
+        {
+            write!(f, [soft_block_indent(&format_inner)])?;
+        } else {
+            write!(f, [format_inner])?;
+        }
+
+        write![f, [r_curly_token.format()]]
     }
 }
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 c43175a0a21..9d921cebec7 100644
--- a/crates/rome_js_formatter/src/jsx/auxiliary/expression_child.rs
+++ b/crates/rome_js_formatter/src/jsx/auxiliary/expression_child.rs
@@ -3,7 +3,7 @@ use crate::prelude::*;
 use crate::prelude::{format_args, write};
 
 use crate::utils::JsAnyBinaryLikeExpression;
-use rome_formatter::{group, FormatResult};
+use rome_formatter::{group, CstFormatContext, FormatResult};
 use rome_js_syntax::{JsAnyExpression, JsxExpressionChild, JsxExpressionChildFields};
 
 #[derive(Debug, Clone, Default)]
@@ -17,36 +17,70 @@ impl FormatNodeRule<JsxExpressionChild> for FormatJsxExpressionChild {
             r_curly_token,
         } = node.as_fields();
 
-        let should_inline = expression.as_ref().map_or(true, |expression| {
-            if matches!(expression, JsAnyExpression::JsConditionalExpression(_))
-                || JsAnyBinaryLikeExpression::can_cast(expression.syntax().kind())
-            {
-                true
-            } else {
-                should_inline_jsx_expression(expression)
+        match expression {
+            Some(expression) => {
+                let comments = f.context().comments();
+                let is_conditional_or_binary =
+                    matches!(expression, JsAnyExpression::JsConditionalExpression(_))
+                        || JsAnyBinaryLikeExpression::can_cast(expression.syntax().kind());
+
+                let should_inline = !comments.has_comments(expression.syntax())
+                    && (is_conditional_or_binary
+                        || should_inline_jsx_expression(&expression, comments));
+
+                if should_inline {
+                    write!(
+                        f,
+                        [
+                            l_curly_token.format(),
+                            expression.format(),
+                            line_suffix_boundary(),
+                            r_curly_token.format()
+                        ]
+                    )
+                } else {
+                    write!(
+                        f,
+                        [group(&format_args![
+                            l_curly_token.format(),
+                            soft_block_indent(&expression.format()),
+                            line_suffix_boundary(),
+                            r_curly_token.format()
+                        ])]
+                    )
+                }
+            }
+            None => {
+                let has_line_comment = f
+                    .comments()
+                    .leading_dangling_trailing_comments(node.syntax())
+                    .any(|comment| comment.kind().is_line());
+
+                write!(f, [l_curly_token.format()])?;
+
+                if has_line_comment {
+                    write!(
+                        f,
+                        [
+                            format_dangling_comments(node.syntax()).with_block_indent(),
+                            hard_line_break()
+                        ]
+                    )?;
+                } else {
+                    write!(f, [format_dangling_comments(node.syntax())])?;
+                }
+
+                write!(f, [r_curly_token.format()])
             }
-        });
-
-        if should_inline {
-            write!(
-                f,
-                [
-                    l_curly_token.format(),
-                    expression.format(),
-                    line_suffix_boundary(),
-                    r_curly_token.format()
-                ]
-            )
-        } else {
-            write!(
-                f,
-                [group(&format_args![
-                    l_curly_token.format(),
-                    soft_block_indent(&expression.format()),
-                    line_suffix_boundary(),
-                    r_curly_token.format()
-                ])]
-            )
         }
     }
+
+    fn fmt_dangling_comments(
+        &self,
+        _: &JsxExpressionChild,
+        _: &mut JsFormatter,
+    ) -> FormatResult<()> {
+        // Formatted inside of `fmt_fields`
+        Ok(())
+    }
 }
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 db7751ee4d5..736a734c23b 100644
--- a/crates/rome_js_formatter/src/jsx/auxiliary/spread_child.rs
+++ b/crates/rome_js_formatter/src/jsx/auxiliary/spread_child.rs
@@ -15,14 +15,27 @@ impl FormatNodeRule<JsxSpreadChild> for FormatJsxSpreadChild {
             r_curly_token,
         } = node.as_fields();
 
-        write!(
-            f,
-            [
-                l_curly_token.format(),
-                dotdotdot_token.format(),
-                expression.format(),
-                r_curly_token.format()
-            ]
-        )
+        let expression = expression?;
+
+        let format_inner = format_with(|f| {
+            write!(
+                f,
+                [
+                    dotdotdot_token.format(),
+                    expression.format(),
+                    line_suffix_boundary()
+                ]
+            )
+        });
+
+        write!(f, [l_curly_token.format()])?;
+
+        if f.comments().has_comments(expression.syntax()) {
+            write!(f, [soft_block_indent(&format_inner)])?;
+        } else {
+            write!(f, [format_inner])?;
+        }
+
+        write!(f, [r_curly_token.format()])
     }
 }
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 69952ab53fa..43dd82cfd47 100644
--- a/crates/rome_js_formatter/src/jsx/expressions/tag_expression.rs
+++ b/crates/rome_js_formatter/src/jsx/expressions/tag_expression.rs
@@ -1,7 +1,7 @@
 use crate::parentheses::{is_callee, is_tag, NeedsParentheses};
 use crate::prelude::*;
 use crate::utils::jsx::{get_wrap_state, WrapState};
-use rome_formatter::write;
+use rome_formatter::{format_args, write};
 use rome_js_syntax::{
     JsArrowFunctionExpression, JsBinaryExpression, JsBinaryOperator, JsCallArgumentList,
     JsCallExpression, JsSyntaxKind, JsSyntaxNode, JsxExpressionChild, JsxTagExpression,
@@ -17,7 +17,14 @@ impl FormatNodeRule<JsxTagExpression> for FormatJsxTagExpression {
 
         match wrap {
             WrapState::NoWrap => {
-                write![f, [node.tag().format()]]
+                write![
+                    f,
+                    [
+                        format_leading_comments(node.syntax()),
+                        node.tag().format(),
+                        format_trailing_comments(node.syntax())
+                    ]
+                ]
             }
             WrapState::WrapOnBreak => {
                 let should_expand = should_expand(node);
@@ -28,7 +35,14 @@ impl FormatNodeRule<JsxTagExpression> for FormatJsxTagExpression {
                         write!(f, [if_group_breaks(&text("("))])?;
                     }
 
-                    write!(f, [soft_block_indent(&node.tag().format())])?;
+                    write!(
+                        f,
+                        [soft_block_indent(&format_args![
+                            format_leading_comments(node.syntax()),
+                            node.tag().format(),
+                            format_trailing_comments(node.syntax())
+                        ])]
+                    )?;
 
                     if !needs_parentheses {
                         write!(f, [if_group_breaks(&text(")"))])?;
@@ -45,6 +59,16 @@ impl FormatNodeRule<JsxTagExpression> for FormatJsxTagExpression {
     fn needs_parentheses(&self, item: &JsxTagExpression) -> bool {
         item.needs_parentheses()
     }
+
+    fn fmt_leading_comments(&self, _: &JsxTagExpression, _: &mut JsFormatter) -> FormatResult<()> {
+        // Handled as part of `fmt_fields`
+        Ok(())
+    }
+
+    fn fmt_trailing_comments(&self, _: &JsxTagExpression, _: &mut JsFormatter) -> FormatResult<()> {
+        // handled as part of `fmt_fields`
+        Ok(())
+    }
 }
 
 /// This is a very special situation where we're returning a JsxElement
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 ad9d75ad099..171c9e0f80c 100644
--- a/crates/rome_js_formatter/src/jsx/lists/child_list.rs
+++ b/crates/rome_js_formatter/src/jsx/lists/child_list.rs
@@ -4,8 +4,9 @@ use crate::utils::jsx::{
     JsxRawSpace, JsxSpace,
 };
 use crate::JsFormatter;
-use rome_formatter::{format_args, write, FormatRuleWithOptions, VecBuffer};
+use rome_formatter::{format_args, write, CstFormatContext, FormatRuleWithOptions, VecBuffer};
 use rome_js_syntax::{JsxAnyChild, JsxChildList};
+use std::cell::RefCell;
 
 #[derive(Debug, Clone, Default)]
 pub struct FormatJsxChildList {
@@ -25,9 +26,39 @@ impl FormatRule<JsxChildList> for FormatJsxChildList {
     type Context = JsFormatContext;
 
     fn fmt(&self, list: &JsxChildList, f: &mut JsFormatter) -> FormatResult<()> {
+        let result = self.fmt_children(list, f)?;
+
+        match result {
+            FormatChildrenResult::ForceMultiline(format_multiline) => {
+                write!(f, [format_multiline])
+            }
+            FormatChildrenResult::BestFitting {
+                flat_children,
+                expanded_children,
+            } => {
+                write!(f, [best_fitting![flat_children, expanded_children]])
+            }
+        }
+    }
+}
+
+pub(crate) enum FormatChildrenResult {
+    ForceMultiline(FormatMultilineChildren),
+    BestFitting {
+        flat_children: FormatFlatChildren,
+        expanded_children: FormatMultilineChildren,
+    },
+}
+
+impl FormatJsxChildList {
+    pub(crate) fn fmt_children(
+        &self,
+        list: &JsxChildList,
+        f: &mut JsFormatter,
+    ) -> FormatResult<FormatChildrenResult> {
         self.disarm_debug_assertions(list, f);
 
-        let children_meta = self.children_meta(list);
+        let children_meta = self.children_meta(list, f.context().comments());
         let layout = self.layout(children_meta);
 
         let multiline_layout = if children_meta.meaningful_text {
@@ -42,7 +73,7 @@ impl FormatRule<JsxChildList> for FormatJsxChildList {
         let mut last: Option<JsxChild> = None;
         let mut force_multiline = layout.is_multiline();
 
-        let mut children = jsx_split_children(list)?;
+        let mut children = jsx_split_children(list, f.context().comments())?;
 
         // Trim trailing new lines
         if let Some(JsxChild::EmptyLine | JsxChild::Newline) = children.last() {
@@ -194,18 +225,16 @@ impl FormatRule<JsxChildList> for FormatJsxChildList {
             last = Some(child);
         }
 
-        let format_multiline = format_once(|f| write!(f, [block_indent(&multiline.finish())]));
-        let format_flat_children = flat.finish();
-
         if force_multiline {
-            write!(f, [format_multiline])
+            Ok(FormatChildrenResult::ForceMultiline(multiline.finish()?))
         } else {
-            write!(f, [best_fitting![format_flat_children, format_multiline]])
+            Ok(FormatChildrenResult::BestFitting {
+                flat_children: flat.finish()?,
+                expanded_children: multiline.finish()?,
+            })
         }
     }
-}
 
-impl FormatJsxChildList {
     /// Tracks the tokens of [JsxText] and [JsxExpressionChild] nodes to be formatted and
     /// asserts that the suppression comments are checked (they get ignored).
     ///
@@ -213,13 +242,14 @@ impl FormatJsxChildList {
     /// [JsxText] and [JsxExpressionChild] and instead, formats the nodes itself.
     #[cfg(debug_assertions)]
     fn disarm_debug_assertions(&self, node: &JsxChildList, f: &mut JsFormatter) {
-        use rome_formatter::CstFormatContext;
         use rome_js_syntax::{JsAnyExpression, JsAnyLiteralExpression};
         use JsxAnyChild::*;
 
         for child in node {
             match child {
-                JsxExpressionChild(expression) if is_whitespace_jsx_expression(&expression) => {
+                JsxExpressionChild(expression)
+                    if is_whitespace_jsx_expression(&expression, f.context().comments()) =>
+                {
                     f.context()
                         .comments()
                         .mark_suppression_checked(expression.syntax());
@@ -275,7 +305,7 @@ impl FormatJsxChildList {
     }
 
     /// Computes additional meta data about the children by iterating once over all children.
-    fn children_meta(&self, list: &JsxChildList) -> ChildrenMeta {
+    fn children_meta(&self, list: &JsxChildList, comments: &JsComments) -> ChildrenMeta {
         let mut has_expression = false;
 
         let mut meta = ChildrenMeta::default();
@@ -285,7 +315,9 @@ impl FormatJsxChildList {
 
             match child {
                 JsxElement(_) | JsxFragment(_) | JsxSelfClosingElement(_) => meta.any_tag = true,
-                JsxExpressionChild(expression) if !is_whitespace_jsx_expression(&expression) => {
+                JsxExpressionChild(expression)
+                    if !is_whitespace_jsx_expression(&expression, comments) =>
+                {
                     meta.multiple_expressions = has_expression;
                     has_expression = true;
                 }
@@ -508,17 +540,30 @@ impl MultilineBuilder {
         })
     }
 
-    fn finish(self) -> impl Format<JsFormatContext> {
-        format_once(move |f| {
-            let elements = self.result?;
+    fn finish(self) -> FormatResult<FormatMultilineChildren> {
+        Ok(FormatMultilineChildren {
+            layout: self.layout,
+            elements: RefCell::new(self.result?),
+        })
+    }
+}
 
-            match self.layout {
-                MultilineLayout::Fill => {
-                    f.write_element(FormatElement::Fill(elements.into_boxed_slice()))
-                }
-                MultilineLayout::NoFill => f.write_elements(elements),
+pub(crate) struct FormatMultilineChildren {
+    layout: MultilineLayout,
+    elements: RefCell<Vec<FormatElement>>,
+}
+
+impl Format<JsFormatContext> for FormatMultilineChildren {
+    fn fmt(&self, f: &mut Formatter<JsFormatContext>) -> FormatResult<()> {
+        let elements = self.elements.take();
+        let format_inner = format_once(|f| match self.layout {
+            MultilineLayout::Fill => {
+                f.write_element(FormatElement::Fill(elements.into_boxed_slice()))
             }
-        })
+            MultilineLayout::NoFill => f.write_elements(elements),
+        });
+
+        write!(f, [block_indent(&format_inner)])
     }
 }
 
@@ -556,12 +601,22 @@ impl FlatBuilder {
         self.disabled = true;
     }
 
-    fn finish(self) -> impl Format<JsFormatContext> {
-        format_once(move |f| {
-            assert!(!self.disabled, "The flat builder has been disabled and thus, does no longer store any elements. Make sure you don't call disable if you later intend to format the flat content.");
+    fn finish(self) -> FormatResult<FormatFlatChildren> {
+        assert!(!self.disabled, "The flat builder has been disabled and thus, does no longer store any elements. Make sure you don't call disable if you later intend to format the flat content.");
 
-            let elements = self.result?;
-            f.write_elements(elements)
+        Ok(FormatFlatChildren {
+            elements: RefCell::new(self.result?),
         })
     }
 }
+
+pub(crate) struct FormatFlatChildren {
+    elements: RefCell<Vec<FormatElement>>,
+}
+
+impl Format<JsFormatContext> for FormatFlatChildren {
+    fn fmt(&self, f: &mut Formatter<JsFormatContext>) -> FormatResult<()> {
+        let elements = self.elements.take();
+        f.write_elements(elements)
+    }
+}
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 2c49a0dec43..a713bf84353 100644
--- a/crates/rome_js_formatter/src/jsx/tag/closing_fragment.rs
+++ b/crates/rome_js_formatter/src/jsx/tag/closing_fragment.rs
@@ -14,13 +14,45 @@ impl FormatNodeRule<JsxClosingFragment> for FormatJsxClosingFragment {
             l_angle_token,
         } = node.as_fields();
 
+        let mut has_own_line_comment = false;
+        let mut has_comment = false;
+
+        for comment in f
+            .comments()
+            .leading_dangling_trailing_comments(node.syntax())
+        {
+            has_comment = true;
+            has_own_line_comment = has_own_line_comment || comment.kind().is_line()
+        }
+
+        let format_comments = format_with(|f| {
+            if has_own_line_comment {
+                write!(f, [hard_line_break()])?;
+            } else if has_comment {
+                write!(f, [space()])?;
+            }
+
+            write!(f, [format_dangling_comments(node.syntax())])
+        });
+
         write![
             f,
             [
                 l_angle_token.format(),
                 slash_token.format(),
+                indent(&format_comments),
+                has_own_line_comment.then_some(hard_line_break()),
                 r_angle_token.format()
             ]
         ]
     }
+
+    fn fmt_dangling_comments(
+        &self,
+        _: &JsxClosingFragment,
+        _: &mut JsFormatter,
+    ) -> FormatResult<()> {
+        // Formatted as part of `fmt_fields`
+        Ok(())
+    }
 }
diff --git a/crates/rome_js_formatter/src/jsx/tag/element.rs b/crates/rome_js_formatter/src/jsx/tag/element.rs
index 03e4607546b..b01d11d9477 100644
--- a/crates/rome_js_formatter/src/jsx/tag/element.rs
+++ b/crates/rome_js_formatter/src/jsx/tag/element.rs
@@ -1,8 +1,8 @@
 use crate::prelude::*;
 
-use crate::jsx::lists::child_list::JsxChildListLayout;
-use crate::utils::jsx::is_meaningful_jsx_text;
-use rome_formatter::{write, CstFormatContext, FormatResult};
+use crate::jsx::lists::child_list::{FormatChildrenResult, FormatJsxChildList, JsxChildListLayout};
+use crate::utils::jsx::{is_jsx_suppressed, is_meaningful_jsx_text};
+use rome_formatter::{format_args, write, CstFormatContext, FormatResult, FormatRuleWithOptions};
 use rome_js_syntax::{
     JsAnyExpression, JsxAnyChild, JsxChildList, JsxElement, JsxExpressionChild, JsxFragment,
 };
@@ -15,6 +15,34 @@ impl FormatNodeRule<JsxElement> for FormatJsxElement {
     fn fmt_fields(&self, node: &JsxElement, f: &mut JsFormatter) -> FormatResult<()> {
         JsxAnyTagWithChildren::from(node.clone()).fmt(f)
     }
+
+    fn is_suppressed(&self, node: &JsxElement, f: &JsFormatter) -> bool {
+        is_jsx_suppressed(&node.clone().into(), f.comments())
+    }
+
+    fn fmt_leading_comments(&self, node: &JsxElement, f: &mut JsFormatter) -> FormatResult<()> {
+        debug_assert!(
+            !f.comments().has_leading_comments(node.syntax()),
+            "JsxElement can not have comments."
+        );
+        Ok(())
+    }
+
+    fn fmt_dangling_comments(&self, node: &JsxElement, f: &mut JsFormatter) -> FormatResult<()> {
+        debug_assert!(
+            !f.comments().has_dangling_comments(node.syntax()),
+            "JsxElement can not have comments."
+        );
+        Ok(())
+    }
+
+    fn fmt_trailing_comments(&self, node: &JsxElement, f: &mut JsFormatter) -> FormatResult<()> {
+        debug_assert!(
+            !f.comments().has_trailing_comments(node.syntax()),
+            "JsxElement can not have comments."
+        );
+        Ok(())
+    }
 }
 
 declare_node_union! {
@@ -38,9 +66,8 @@ impl Format<JsFormatContext> for JsxAnyTagWithChildren {
             }
 
             ElementLayout::Default => {
-                let mut recording = f.start_recording();
-                write!(recording, [format_opening])?;
-                let opening_breaks = recording.stop().iter().any(FormatElement::will_break);
+                let mut format_opening = format_opening.memoized();
+                let opening_breaks = format_opening.inspect(f)?.will_break();
 
                 let multiple_attributes = match self {
                     JsxAnyTagWithChildren::JsxElement(element) => {
@@ -55,13 +82,29 @@ impl Format<JsFormatContext> for JsxAnyTagWithChildren {
                     JsxChildListLayout::BestFitting
                 };
 
-                write!(
-                    f,
-                    [
-                        self.children().format().with_options(list_layout),
-                        format_closing
-                    ]
-                )
+                let children = self.children();
+                let format_children = FormatJsxChildList::default()
+                    .with_options(list_layout)
+                    .fmt_children(&children, f)?;
+
+                match format_children {
+                    FormatChildrenResult::ForceMultiline(multiline) => {
+                        write!(f, [format_opening, multiline, format_closing])
+                    }
+                    FormatChildrenResult::BestFitting {
+                        flat_children,
+                        expanded_children,
+                    } => {
+                        let format_closing = format_closing.memoized();
+                        write!(
+                            f,
+                            [best_fitting![
+                                format_args![format_opening, flat_children, format_closing],
+                                format_args![format_opening, expanded_children, format_closing]
+                            ]]
+                        )
+                    }
+                }
             }
         }
     }
diff --git a/crates/rome_js_formatter/src/jsx/tag/fragment.rs b/crates/rome_js_formatter/src/jsx/tag/fragment.rs
index b8a4a7335db..7f976644468 100644
--- a/crates/rome_js_formatter/src/jsx/tag/fragment.rs
+++ b/crates/rome_js_formatter/src/jsx/tag/fragment.rs
@@ -1,6 +1,7 @@
 use crate::prelude::*;
 
 use crate::jsx::tag::element::JsxAnyTagWithChildren;
+use crate::utils::jsx::is_jsx_suppressed;
 use rome_formatter::write;
 use rome_js_syntax::JsxFragment;
 
@@ -11,4 +12,32 @@ impl FormatNodeRule<JsxFragment> for FormatJsxFragment {
     fn fmt_fields(&self, node: &JsxFragment, f: &mut JsFormatter) -> FormatResult<()> {
         write!(f, [JsxAnyTagWithChildren::from(node.clone())])
     }
+
+    fn is_suppressed(&self, node: &JsxFragment, f: &JsFormatter) -> bool {
+        is_jsx_suppressed(&node.clone().into(), f.comments())
+    }
+
+    fn fmt_leading_comments(&self, node: &JsxFragment, f: &mut JsFormatter) -> FormatResult<()> {
+        debug_assert!(
+            !f.comments().has_leading_comments(node.syntax()),
+            "JsxFragment can not have comments."
+        );
+        Ok(())
+    }
+
+    fn fmt_dangling_comments(&self, node: &JsxFragment, f: &mut JsFormatter) -> FormatResult<()> {
+        debug_assert!(
+            !f.comments().has_dangling_comments(node.syntax()),
+            "JsxFragment can not have comments."
+        );
+        Ok(())
+    }
+
+    fn fmt_trailing_comments(&self, node: &JsxFragment, f: &mut JsFormatter) -> FormatResult<()> {
+        debug_assert!(
+            !f.comments().has_trailing_comments(node.syntax()),
+            "JsxFragment can not have comments."
+        );
+        Ok(())
+    }
 }
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 27358b9a9c6..3030e3c4e51 100644
--- a/crates/rome_js_formatter/src/jsx/tag/opening_element.rs
+++ b/crates/rome_js_formatter/src/jsx/tag/opening_element.rs
@@ -1,6 +1,6 @@
 use crate::prelude::*;
 
-use rome_formatter::write;
+use rome_formatter::{write, CstFormatContext};
 use rome_js_syntax::{
     JsSyntaxToken, JsxAnyAttribute, JsxAnyAttributeValue, JsxAnyElementName, JsxAttributeList,
     JsxOpeningElement, JsxSelfClosingElement, JsxString, TsTypeArguments,
@@ -22,7 +22,7 @@ declare_node_union! {
 
 impl Format<JsFormatContext> for JsxAnyOpeningElement {
     fn fmt(&self, f: &mut Formatter<JsFormatContext>) -> FormatResult<()> {
-        let layout = self.compute_layout()?;
+        let layout = self.compute_layout(f.context().comments())?;
 
         let l_angle_token = self.l_angle_token()?;
         let name = self.name()?;
@@ -150,23 +150,21 @@ impl JsxAnyOpeningElement {
         matches!(self, JsxAnyOpeningElement::JsxSelfClosingElement(_))
     }
 
-    fn compute_layout(&self) -> SyntaxResult<OpeningElementLayout> {
+    fn compute_layout(&self, comments: &JsComments) -> SyntaxResult<OpeningElementLayout> {
         let attributes = self.attributes();
-        let l_angle_token = self.l_angle_token()?;
         let name = self.name()?;
 
-        let name_has_comments = l_angle_token.has_trailing_comments()
-            || name.syntax().has_comments_direct()
+        let name_has_comments = comments.has_comments(name.syntax())
             || self
                 .type_arguments()
-                .map_or(false, |arguments| arguments.syntax().has_comments_direct());
+                .map_or(false, |arguments| comments.has_comments(arguments.syntax()));
 
         let layout = if self.is_self_closing() && attributes.is_empty() && !name_has_comments {
             OpeningElementLayout::Inline
         } else if attributes.len() == 1
             && attributes.iter().all(|attribute| {
                 is_single_line_string_literal_attribute(&attribute)
-                    && !attribute.syntax().has_comments_direct()
+                    && !comments.has_comments(attribute.syntax())
             })
             && !name_has_comments
         {
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 ccc44ceaa30..0e222bc91eb 100644
--- a/crates/rome_js_formatter/src/jsx/tag/opening_fragment.rs
+++ b/crates/rome_js_formatter/src/jsx/tag/opening_fragment.rs
@@ -13,6 +13,36 @@ impl FormatNodeRule<JsxOpeningFragment> for FormatJsxOpeningFragment {
             l_angle_token,
         } = node.as_fields();
 
-        write![f, [l_angle_token.format(), r_angle_token.format()]]
+        let has_own_line_comment = f
+            .comments()
+            .leading_dangling_trailing_comments(node.syntax())
+            .any(|comment| comment.kind().is_line());
+
+        let format_comments = format_with(|f| {
+            if has_own_line_comment {
+                write!(f, [hard_line_break()])?;
+            }
+
+            write!(f, [format_dangling_comments(node.syntax())])
+        });
+
+        write![
+            f,
+            [
+                l_angle_token.format(),
+                indent(&format_comments),
+                has_own_line_comment.then_some(hard_line_break()),
+                r_angle_token.format()
+            ]
+        ]
+    }
+
+    fn fmt_dangling_comments(
+        &self,
+        _: &JsxOpeningFragment,
+        _: &mut JsFormatter,
+    ) -> FormatResult<()> {
+        // Handled as part of `fmt_fields`
+        Ok(())
     }
 }
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 22f0a599793..158a5cd390c 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
@@ -2,6 +2,7 @@ use crate::prelude::*;
 
 use crate::jsx::tag::opening_element::JsxAnyOpeningElement;
 
+use crate::utils::jsx::is_jsx_suppressed;
 use rome_js_syntax::JsxSelfClosingElement;
 
 #[derive(Debug, Clone, Default)]
@@ -11,4 +12,44 @@ impl FormatNodeRule<JsxSelfClosingElement> for FormatJsxSelfClosingElement {
     fn fmt_fields(&self, node: &JsxSelfClosingElement, f: &mut JsFormatter) -> FormatResult<()> {
         JsxAnyOpeningElement::from(node.clone()).fmt(f)
     }
+
+    fn is_suppressed(&self, node: &JsxSelfClosingElement, f: &JsFormatter) -> bool {
+        is_jsx_suppressed(&node.clone().into(), f.comments())
+    }
+
+    fn fmt_leading_comments(
+        &self,
+        node: &JsxSelfClosingElement,
+        f: &mut JsFormatter,
+    ) -> FormatResult<()> {
+        debug_assert!(
+            !f.comments().has_leading_comments(node.syntax()),
+            "JsxSelfClosingElement can not have comments."
+        );
+        Ok(())
+    }
+
+    fn fmt_dangling_comments(
+        &self,
+        node: &JsxSelfClosingElement,
+        f: &mut JsFormatter,
+    ) -> FormatResult<()> {
+        debug_assert!(
+            !f.comments().has_dangling_comments(node.syntax()),
+            "JsxSelfClosingElement can not have comments."
+        );
+        Ok(())
+    }
+
+    fn fmt_trailing_comments(
+        &self,
+        node: &JsxSelfClosingElement,
+        f: &mut JsFormatter,
+    ) -> FormatResult<()> {
+        debug_assert!(
+            !f.comments().has_trailing_comments(node.syntax()),
+            "JsxSelfClosingElement can not have comments."
+        );
+        Ok(())
+    }
 }
diff --git a/crates/rome_js_formatter/src/lib.rs b/crates/rome_js_formatter/src/lib.rs
index cf9e0abd760..04b4b4141cb 100644
--- a/crates/rome_js_formatter/src/lib.rs
+++ b/crates/rome_js_formatter/src/lib.rs
@@ -810,7 +810,7 @@ function() {
 }"#
         );
 
-        let tree = parse_script(input, 0);
+        let tree = parse_script(input, FileId::zero());
         let result = format_range(
             JsFormatOptions::new(SourceType::js_script()).with_indent_style(IndentStyle::Space(4)),
             &tree.syntax(),
@@ -830,15 +830,42 @@ function() {
         )
     }
 
+    #[test]
+    fn range_formatting_trailing_comments() {
+        let input = r#"let fn =a((x ) => {
+          quux (); //
+        });
+"#;
+
+        let range = TextRange::new(TextSize::from(28), TextSize::from(41));
+
+        debug_assert_eq!(&input[range], r#"  quux (); //"#);
+
+        let tree = parse_script(input, FileId::zero());
+        let result = format_range(
+            JsFormatOptions::new(SourceType::js_script()).with_indent_style(IndentStyle::Space(4)),
+            &tree.syntax(),
+            range,
+        )
+        .expect("Range formatting failed");
+
+        assert_eq!(result.as_code(), r#"quux(); //"#);
+        assert_eq!(
+            result.range(),
+            Some(TextRange::new(TextSize::from(30), TextSize::from(41)))
+        )
+    }
+
     #[ignore]
     #[test]
     // use this test check if your snippet prints as you wish, without using a snapshot
     fn quick_test() {
-        let src = r#"
-        type C = B & (C | A) & B;
+        let src = r#"long_obj =
+  <div style={{ i: 'dont', use: 'bootstrap', and: 'instead', use: 'massive', objects }}>hello world</div>
+
 
 "#;
-        let syntax = SourceType::tsx();
+        let syntax = SourceType::jsx();
         let tree = parse(src, FileId::zero(), syntax);
         let options = JsFormatOptions::new(syntax);
 
diff --git a/crates/rome_js_formatter/src/syntax_rewriter.rs b/crates/rome_js_formatter/src/syntax_rewriter.rs
index 4fdd26c3c23..d6323f6e694 100644
--- a/crates/rome_js_formatter/src/syntax_rewriter.rs
+++ b/crates/rome_js_formatter/src/syntax_rewriter.rs
@@ -1,6 +1,5 @@
 use crate::comments::is_type_comment;
 use crate::parentheses::JsAnyParenthesized;
-use crate::TextRange;
 use rome_formatter::{TransformSourceMap, TransformSourceMapBuilder};
 use rome_js_syntax::{
     JsAnyAssignment, JsAnyExpression, JsLanguage, JsLogicalExpression, JsSyntaxKind, JsSyntaxNode,
@@ -8,8 +7,9 @@ use rome_js_syntax::{
 };
 use rome_rowan::syntax::SyntaxTrivia;
 use rome_rowan::{
-    AstNode, SyntaxKind, SyntaxRewriter, SyntaxToken, SyntaxTriviaPiece, VisitNodeSignal,
+    AstNode, SyntaxKind, SyntaxRewriter, SyntaxToken, SyntaxTriviaPiece, TextSize, VisitNodeSignal,
 };
+use std::collections::BTreeSet;
 use std::iter::FusedIterator;
 
 pub(super) fn transform(root: JsSyntaxNode) -> (JsSyntaxNode, TransformSourceMap) {
@@ -21,6 +21,26 @@ pub(super) fn transform(root: JsSyntaxNode) -> (JsSyntaxNode, TransformSourceMap
 #[derive(Default)]
 struct JsFormatSyntaxRewriter {
     source_map: TransformSourceMapBuilder,
+
+    /// Stores a map of the positions at which a `(` paren has been removed.
+    /// This is necessary for correctly computing the source offsets for nested parenthesized expressions with whitespace:
+    ///
+    /// ```javascript
+    /// function f() {
+    ///     return (
+    ///         (
+    ///             // prettier-ignore
+    ///             /* $FlowFixMe(>=0.53.0) */
+    ///             <JSX />
+    ///         )
+    ///     );
+    /// }
+    /// ```
+    /// The rewriter first removes any leading whitespace from the `JsxTagExpression`'s leading trivia.
+    /// However, it then removes the leading/trailing whitespace of the inner `(` as well when handling the outer
+    /// parenthesized expressions but the ranges of the `(` trailing trivia pieces no longer match the source ranges because
+    /// they are now off by 1 because of the removed `(`.
+    l_paren_source_position: BTreeSet<TextSize>,
 }
 
 impl JsFormatSyntaxRewriter {
@@ -135,8 +155,9 @@ impl JsFormatSyntaxRewriter {
 
         let inner_trimmed_range = inner.text_trimmed_range();
         // Store away the inner offset because the new returned inner might be a detached node
-        let mut inner_offset = inner.text_range().start();
+        let original_inner_offset = inner.text_range().start();
         let inner = self.transform(inner);
+        let inner_offset = original_inner_offset - inner.text_range().start();
 
         match inner.first_token() {
             // This can only happen if we have `()` which is highly unlikely to ever be the case.
@@ -171,17 +192,17 @@ impl JsFormatSyntaxRewriter {
                     parenthesized.syntax().text_trimmed_range(),
                 );
 
-                self.source_map
-                    .add_deleted_range(l_paren.text_trimmed_range());
+                let l_paren_trimmed_range = l_paren.text_trimmed_range();
+                self.source_map.add_deleted_range(l_paren_trimmed_range);
+                self.l_paren_source_position
+                    .insert(l_paren_trimmed_range.start());
 
                 let mut l_paren_trailing = l_paren.trailing_trivia().pieces().peekable();
 
                 // Skip over leading whitespace
                 while let Some(piece) = l_paren_trailing.peek() {
                     if piece.is_whitespace() {
-                        self.source_map
-                            .add_deleted_range(TextRange::at(inner_offset, piece.text_len()));
-                        inner_offset += piece.text_len();
+                        self.source_map.add_deleted_range(piece.text_range());
                         l_paren_trailing.next();
                     } else {
                         break;
@@ -198,17 +219,26 @@ impl JsFormatSyntaxRewriter {
                 let mut leading_trivia = first_token.leading_trivia().pieces().peekable();
                 let mut first_new_line = None;
 
+                let mut inner_offset = inner_offset;
+
+                // if !is_parent_parenthesized {
                 // The leading whitespace before the opening parens replaces the whitespace before the node.
                 while let Some(trivia) = leading_trivia.peek() {
+                    if self
+                        .l_paren_source_position
+                        .contains(&(trivia.text_range().start() + inner_offset))
+                    {
+                        inner_offset += TextSize::from(1);
+                    }
+
                     if trivia.is_newline() && first_new_line.is_none() {
-                        let trivia_len = trivia.text_len();
-                        first_new_line = Some((inner_offset, leading_trivia.next().unwrap()));
-                        inner_offset += trivia_len;
+                        first_new_line = Some((
+                            trivia.text_range() + inner_offset,
+                            leading_trivia.next().unwrap(),
+                        ));
                     } else if trivia.is_whitespace() || trivia.is_newline() {
-                        let trivia_len = trivia.text_len();
                         self.source_map
-                            .add_deleted_range(TextRange::at(inner_offset, trivia_len));
-                        inner_offset += trivia_len;
+                            .add_deleted_range(trivia.text_range() + inner_offset);
                         leading_trivia.next();
                     } else {
                         break;
@@ -220,11 +250,11 @@ impl JsFormatSyntaxRewriter {
                     && leading_trivia.peek().is_none()
                     && first_new_line.is_some()
                 {
-                    let (inner_offset, new_line) = first_new_line.take().unwrap();
+                    let (inner_offset, _) = first_new_line.take().unwrap();
 
-                    self.source_map
-                        .add_deleted_range(TextRange::at(inner_offset, new_line.text_len()));
+                    self.source_map.add_deleted_range(inner_offset);
                 }
+                // }
 
                 let leading_trivia = chain_pieces(
                     first_new_line.map(|(_, trivia)| trivia).into_iter(),
@@ -503,11 +533,11 @@ mod tests {
     use crate::{format_node, JsFormatOptions, TextRange};
     use rome_diagnostics::file::FileId;
     use rome_formatter::{SourceMarker, TransformSourceMap};
-    use rome_js_parser::parse_module;
+    use rome_js_parser::{parse, parse_module};
     use rome_js_syntax::{
         JsArrayExpression, JsBinaryExpression, JsExpressionStatement, JsIdentifierExpression,
         JsLogicalExpression, JsSequenceExpression, JsStringLiteralExpression, JsSyntaxNode,
-        JsUnaryExpression, SourceType,
+        JsUnaryExpression, JsxTagExpression, SourceType,
     };
     use rome_rowan::{AstNode, SyntaxRewriter, TextSize};
 
@@ -834,8 +864,39 @@ mod tests {
         );
     }
 
+    #[test]
+    fn nested_parentheses_with_whitespace() {
+        let (transformed, source_map) = source_map_test(
+            r#"function f() {
+	return (
+		(
+			// prettier-ignore
+			/* $FlowFixMe(>=0.53.0) */
+			<JSX />
+		)
+	);
+}"#,
+        );
+
+        let tag_expression = transformed
+            .descendants()
+            .find_map(JsxTagExpression::cast)
+            .unwrap();
+
+        assert_eq!(
+            source_map.trimmed_source_text(tag_expression.syntax()),
+            r#"(
+		(
+			// prettier-ignore
+			/* $FlowFixMe(>=0.53.0) */
+			<JSX />
+		)
+	)"#
+        );
+    }
+
     fn source_map_test(input: &str) -> (JsSyntaxNode, TransformSourceMap) {
-        let tree = parse_module(input, FileId::zero()).syntax();
+        let tree = parse(input, FileId::zero(), SourceType::jsx()).syntax();
 
         let mut rewriter = JsFormatSyntaxRewriter::default();
         let transformed = rewriter.transform(tree);
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 4187c061d4b..b7a26d363dd 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
@@ -24,8 +24,9 @@ impl FormatNodeRule<TsTypeAssertionAssignment> for FormatTsTypeAssertionAssignme
         write![
             f,
             [
-                format_delimited(&l_angle_token?, &ty.format(), &r_angle_token?)
-                    .soft_block_indent(),
+                l_angle_token.format(),
+                group(&soft_block_indent(&ty.format())),
+                r_angle_token.format(),
                 assignment.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 210f3504c21..1b180de700e 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
@@ -1,7 +1,7 @@
 use crate::prelude::*;
 use crate::utils::FormatTypeMemberSeparator;
+use rome_formatter::{format_args, write};
 
-use rome_formatter::write;
 use rome_js_syntax::{TsCallSignatureTypeMember, TsCallSignatureTypeMemberFields};
 
 #[derive(Debug, Clone, Default)]
@@ -23,8 +23,7 @@ impl FormatNodeRule<TsCallSignatureTypeMember> for FormatTsCallSignatureTypeMemb
         write!(
             f,
             [
-                type_parameters.format(),
-                parameters.format(),
+                group(&format_args![type_parameters.format(), parameters.format()]),
                 return_type_annotation.format(),
                 FormatTypeMemberSeparator::new(separator_token.as_ref())
             ]
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 b8328d2ba1e..f11dbdb9b6b 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
@@ -1,5 +1,5 @@
 use crate::prelude::*;
-use rome_formatter::write;
+use rome_formatter::{format_args, write};
 
 use crate::utils::FormatTypeMemberSeparator;
 
@@ -27,8 +27,7 @@ impl FormatNodeRule<TsConstructSignatureTypeMember> for FormatTsConstructSignatu
             [
                 new_token.format(),
                 space(),
-                type_parameters.format(),
-                parameters.format(),
+                group(&format_args![type_parameters.format(), parameters.format()]),
                 type_annotation.format(),
                 FormatTypeMemberSeparator::new(separator_token.as_ref()),
             ]
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 0af608dc922..69bce6e1dd6 100644
--- a/crates/rome_js_formatter/src/ts/auxiliary/module_block.rs
+++ b/crates/rome_js_formatter/src/ts/auxiliary/module_block.rs
@@ -15,9 +15,22 @@ impl FormatNodeRule<TsModuleBlock> for FormatTsModuleBlock {
             r_curly_token,
         } = node.as_fields();
 
-        write!(
-            f,
-            [format_delimited(&l_curly_token?, &items.format(), &r_curly_token?,).block_indent()]
-        )
+        write!(f, [l_curly_token.format()])?;
+
+        if items.is_empty() {
+            write!(
+                f,
+                [format_dangling_comments(node.syntax()).with_block_indent()]
+            )?;
+        } else {
+            write!(f, [block_indent(&items.format())])?;
+        }
+
+        write!(f, [r_curly_token.format()])
+    }
+
+    fn fmt_dangling_comments(&self, _: &TsModuleBlock, _: &mut JsFormatter) -> FormatResult<()> {
+        // Handled inside `fmt_fields`
+        Ok(())
     }
 }
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 6000e61f071..112baf7b02d 100644
--- a/crates/rome_js_formatter/src/ts/bindings/type_parameters.rs
+++ b/crates/rome_js_formatter/src/ts/bindings/type_parameters.rs
@@ -1,6 +1,6 @@
 use crate::prelude::*;
-
-use rome_formatter::{write, FormatRuleWithOptions, GroupId};
+use rome_formatter::FormatError::SyntaxError;
+use rome_formatter::{format_args, write, FormatRuleWithOptions, GroupId};
 use rome_js_syntax::{TsTypeParameters, TsTypeParametersFields};
 
 #[derive(Debug, Clone, Default)]
@@ -25,12 +25,18 @@ impl FormatNodeRule<TsTypeParameters> for FormatTsTypeParameters {
             l_angle_token,
         } = node.as_fields();
 
+        if items.is_empty() {
+            return Err(SyntaxError);
+        }
+
         write!(
             f,
-            [
-                format_delimited(&l_angle_token?, &items.format(), &r_angle_token?)
-                    .soft_block_indent_with_group_id(self.group_id)
-            ]
+            [group(&format_args![
+                l_angle_token.format(),
+                soft_block_indent(&items.format()),
+                r_angle_token.format()
+            ])
+            .with_group_id(self.group_id)]
         )
     }
 }
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 e72320198bd..6e5eded1ac8 100644
--- a/crates/rome_js_formatter/src/ts/classes/extends_clause.rs
+++ b/crates/rome_js_formatter/src/ts/classes/extends_clause.rs
@@ -13,9 +13,12 @@ impl FormatNodeRule<TsExtendsClause> for FormatTsExtendsClause {
             types,
         } = node.as_fields();
 
-        write!(
-            f,
-            [extends_token.format(), space(), &indent(&types.format())]
-        )
+        write!(f, [extends_token.format(), space()])?;
+
+        if types.len() == 1 {
+            write!(f, [types.format()])
+        } else {
+            write!(f, [indent(&types.format())])
+        }
     }
 }
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 9e818212d00..f952d67fc31 100644
--- a/crates/rome_js_formatter/src/ts/declarations/enum_declaration.rs
+++ b/crates/rome_js_formatter/src/ts/declarations/enum_declaration.rs
@@ -28,8 +28,9 @@ impl FormatNodeRule<TsEnumDeclaration> for FormatTsEnumDeclaration {
                 space(),
                 id.format(),
                 space(),
-                format_delimited(&l_curly_token?, &members.format(), &r_curly_token?,)
-                    .soft_block_spaces()
+                l_curly_token.format(),
+                group(&soft_space_or_block_indent(&members.format())),
+                r_curly_token.format()
             ]
         )
     }
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 b157191d618..18f54d77818 100644
--- a/crates/rome_js_formatter/src/ts/declarations/interface_declaration.rs
+++ b/crates/rome_js_formatter/src/ts/declarations/interface_declaration.rs
@@ -23,9 +23,15 @@ impl FormatNodeRule<TsInterfaceDeclaration> for FormatTsInterfaceDeclaration {
         let id = id?;
         let type_parameters = type_parameters;
 
-        let type_parameter_group = type_parameters
-            .as_ref()
-            .map(|_| f.group_id("type-parameters"));
+        let should_indent_extends_only = type_parameters.as_ref().map_or(false, |params| {
+            !f.comments().has_trailing_line_comment(params.syntax())
+        });
+
+        let type_parameter_group = if should_indent_extends_only && extends_clause.is_some() {
+            Some(f.group_id("type_parameters"))
+        } else {
+            None
+        };
 
         let format_id = format_with(|f| {
             write!(f, [id.format(),])?;
@@ -40,10 +46,6 @@ impl FormatNodeRule<TsInterfaceDeclaration> for FormatTsInterfaceDeclaration {
             Ok(())
         });
 
-        let should_indent_extends_only = type_parameters
-            .as_ref()
-            .map_or(false, |params| !params.syntax().has_trailing_comments());
-
         let format_extends = format_with(|f| {
             if let Some(extends_clause) = &extends_clause {
                 if should_indent_extends_only {
@@ -67,29 +69,7 @@ impl FormatNodeRule<TsInterfaceDeclaration> for FormatTsInterfaceDeclaration {
 
         write![f, [interface_token.format(), space()]]?;
 
-        // Manually handle the trailing comments and push them into the members block
-        // to prevent that a comment gets formatted on the same line as the opening `{`
-        let last_node = match (&type_parameters, &extends_clause) {
-            (_, Some(extends_clause)) => extends_clause.syntax(),
-            (Some(type_parameters), None) => type_parameters.syntax(),
-            (None, None) => id.syntax(),
-        };
-
-        let last_token = last_node.last_token();
-        let mut has_trailing_comments = false;
-
-        if let Some(last_token) = &last_token {
-            for comment in last_token
-                .trailing_trivia()
-                .pieces()
-                .filter_map(|piece| piece.as_comments())
-            {
-                has_trailing_comments = true;
-                f.state_mut().mark_comment_as_formatted(&comment);
-            }
-        }
-
-        let id_has_trailing_comments = id.syntax().has_trailing_comments();
+        let id_has_trailing_comments = f.comments().has_trailing_comments(id.syntax());
         if id_has_trailing_comments || extends_clause.is_some() {
             if should_indent_extends_only {
                 write!(
@@ -106,36 +86,26 @@ impl FormatNodeRule<TsInterfaceDeclaration> for FormatTsInterfaceDeclaration {
             write!(f, [format_id, format_extends])?;
         }
 
-        write!(
-            f,
-            [
-                space(),
-                format_delimited(
-                    &l_curly_token,
-                    &format_args![
-                        format_with(|f| {
-                            // Write the manual handled comments
-                            if let Some(last_token) = &last_token {
-                                if has_trailing_comments {
-                                    write!(
-                                        f,
-                                        [
-                                            format_trailing_trivia(last_token)
-                                                .skip_formatted_check(),
-                                            hard_line_break()
-                                        ]
-                                    )?;
-                                }
-                            }
-
-                            Ok(())
-                        }),
-                        members.format()
-                    ],
-                    &r_curly_token
-                )
-                .block_indent()
-            ]
-        )
+        write!(f, [space(), l_curly_token.format()])?;
+
+        if members.is_empty() {
+            write!(
+                f,
+                [format_dangling_comments(node.syntax()).with_block_indent()]
+            )?;
+        } else {
+            write!(f, [block_indent(&members.format())])?;
+        }
+
+        write!(f, [r_curly_token.format()])
+    }
+
+    fn fmt_dangling_comments(
+        &self,
+        _: &TsInterfaceDeclaration,
+        _: &mut JsFormatter,
+    ) -> FormatResult<()> {
+        // Handled inside of `fmt_fields`
+        Ok(())
     }
 }
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 99aaf01b1d2..3ea9ff9be03 100644
--- a/crates/rome_js_formatter/src/ts/expressions/type_arguments.rs
+++ b/crates/rome_js_formatter/src/ts/expressions/type_arguments.rs
@@ -1,6 +1,7 @@
 use crate::utils::should_hug_type;
 use crate::{prelude::*, utils::is_object_like_type};
 use rome_formatter::write;
+use rome_formatter::FormatError::SyntaxError;
 use rome_js_syntax::{
     JsAnyExpression, JsSyntaxKind, JsVariableDeclarator, TsType, TsTypeArguments,
     TsTypeArgumentsFields,
@@ -17,6 +18,10 @@ impl FormatNodeRule<TsTypeArguments> for FormatTsTypeArguments {
             r_angle_token,
         } = node.as_fields();
 
+        if ts_type_argument_list.is_empty() {
+            return Err(SyntaxError);
+        }
+
         // We want to check if we are inside something like this:
         // const foo: SomeThing<{ [P in "x" | "y"]: number }> = func();
         //
@@ -71,25 +76,17 @@ impl FormatNodeRule<TsTypeArguments> for FormatTsTypeArguments {
         let should_inline = !is_arrow_function_variables
             && (ts_type_argument_list.len() == 0 || first_argument_can_be_hugged_or_is_null_type);
 
+        write!(f, [l_angle_token.format(),])?;
+
         if should_inline {
-            write!(
-                f,
-                [
-                    l_angle_token.format(),
-                    ts_type_argument_list.format(),
-                    r_angle_token.format(),
-                ]
-            )
+            write!(f, [ts_type_argument_list.format()])?;
         } else {
             write!(
                 f,
-                [format_delimited(
-                    &l_angle_token?,
-                    &ts_type_argument_list.format(),
-                    &r_angle_token?,
-                )
-                .soft_block_indent()]
-            )
+                [group(&soft_block_indent(&ts_type_argument_list.format()))]
+            )?;
         }
+
+        write!(f, [r_angle_token.format()])
     }
 }
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 7e81376a0fc..254da605f18 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
@@ -24,8 +24,9 @@ impl FormatNodeRule<TsTypeAssertionExpression> for FormatTsTypeAssertionExpressi
         write![
             f,
             [
-                format_delimited(&l_angle_token?, &ty.format(), &r_angle_token?,)
-                    .soft_block_indent(),
+                l_angle_token.format(),
+                group(&soft_block_indent(&ty.format())),
+                r_angle_token.format(),
                 expression.format()
             ]
         ]
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 47ea34b7581..5c5efd577db 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
@@ -1,6 +1,6 @@
 use crate::prelude::*;
 use crate::utils::node_has_leading_newline;
-use rome_js_syntax::{JsSyntaxKind, TsEnumMemberList};
+use rome_js_syntax::TsEnumMemberList;
 
 #[derive(Debug, Clone, Default)]
 pub struct FormatTsEnumMemberList;
@@ -16,7 +16,7 @@ impl FormatRule<TsEnumMemberList> for FormatTsEnumMemberList {
         } else {
             soft_line_break_or_space()
         })
-        .entries(node.format_separated(JsSyntaxKind::COMMA).nodes_grouped())
+        .entries(node.format_separated(",").nodes_grouped())
         .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 fad9b26bdf5..ae6214c9292 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
@@ -1,5 +1,5 @@
 use crate::prelude::*;
-use rome_js_syntax::{JsSyntaxKind, TsTupleTypeElementList};
+use rome_js_syntax::TsTupleTypeElementList;
 
 #[derive(Debug, Clone, Default)]
 pub struct FormatTsTupleTypeElementList;
@@ -9,7 +9,7 @@ impl FormatRule<TsTupleTypeElementList> for FormatTsTupleTypeElementList {
 
     fn fmt(&self, node: &TsTupleTypeElementList, f: &mut JsFormatter) -> FormatResult<()> {
         f.join_with(&soft_line_break_or_space())
-            .entries(node.format_separated(JsSyntaxKind::COMMA).nodes_grouped())
+            .entries(node.format_separated(",").nodes_grouped())
             .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 7b1f9b4bcbf..448098e2462 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
@@ -1,5 +1,5 @@
 use crate::prelude::*;
-use rome_js_syntax::{JsSyntaxKind, TsTypeArgumentList};
+use rome_js_syntax::TsTypeArgumentList;
 
 #[derive(Debug, Clone, Default)]
 pub struct FormatTsTypeArgumentList;
@@ -10,7 +10,7 @@ impl FormatRule<TsTypeArgumentList> for FormatTsTypeArgumentList {
     fn fmt(&self, node: &TsTypeArgumentList, f: &mut JsFormatter) -> FormatResult<()> {
         f.join_with(&soft_line_break_or_space())
             .entries(
-                node.format_separated(JsSyntaxKind::COMMA)
+                node.format_separated(",")
                     .with_trailing_separator(TrailingSeparator::Disallowed),
             )
             .finish()
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 3cefbbebfc4..afeaa010d0e 100644
--- a/crates/rome_js_formatter/src/ts/lists/type_list.rs
+++ b/crates/rome_js_formatter/src/ts/lists/type_list.rs
@@ -1,5 +1,5 @@
 use crate::prelude::*;
-use rome_js_syntax::{JsSyntaxKind, TsTypeList};
+use rome_js_syntax::TsTypeList;
 
 #[derive(Debug, Clone, Default)]
 pub struct FormatTsTypeList;
@@ -11,7 +11,7 @@ impl FormatRule<TsTypeList> for FormatTsTypeList {
         // the grouping will be applied by the parent
         f.join_with(&soft_line_break_or_space())
             .entries(
-                node.format_separated(JsSyntaxKind::COMMA)
+                node.format_separated(",")
                     .with_trailing_separator(TrailingSeparator::Disallowed),
             )
             .finish()
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 8c295c32e31..912efe6fa91 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
@@ -1,6 +1,6 @@
 use crate::prelude::*;
 use rome_formatter::{write, Buffer};
-use rome_js_syntax::{JsSyntaxKind, TsAnyTypeMember, TsTypeMemberList};
+use rome_js_syntax::{TsAnyTypeMember, TsTypeMemberList};
 
 use rome_rowan::AstNodeList;
 
@@ -50,12 +50,9 @@ impl Format<JsFormatContext> 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(&format_inserted(JsSyntaxKind::SEMICOLON))]
-                )?;
+                write!(f, [if_group_breaks(&text(";"))])?;
             } else {
-                format_inserted(JsSyntaxKind::SEMICOLON).fmt(f)?;
+                text(";").fmt(f)?;
             }
         }
 
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 1f0a83a1fca..f7680999d4e 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
@@ -1,5 +1,5 @@
 use crate::prelude::*;
-use rome_js_syntax::{JsSyntaxKind, TsTypeParameterList};
+use rome_js_syntax::TsTypeParameterList;
 use rome_rowan::AstSeparatedList;
 
 #[derive(Debug, Clone, Default)]
@@ -23,7 +23,7 @@ impl FormatRule<TsTypeParameterList> for FormatTsTypeParameterList {
 
         f.join_with(&soft_line_break_or_space())
             .entries(
-                node.format_separated(JsSyntaxKind::COMMA)
+                node.format_separated(",")
                     .with_trailing_separator(trailing_separator),
             )
             .finish()
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 b466695e235..e59efa03743 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
@@ -1,7 +1,42 @@
 use crate::prelude::*;
+use crate::ts::expressions::template_literal_type::FormatTsTemplateLiteralType;
+use crate::ts::module::import_type::FormatTsImportType;
+use crate::ts::types::any_type::FormatTsAnyType;
+use crate::ts::types::array_type::FormatTsArrayType;
+use crate::ts::types::big_int_literal_type::FormatTsBigIntLiteralType;
+use crate::ts::types::bigint_type::FormatTsBigintType;
+use crate::ts::types::boolean_literal_type::FormatTsBooleanLiteralType;
+use crate::ts::types::boolean_type::FormatTsBooleanType;
+use crate::ts::types::conditional_type::FormatTsConditionalType;
+use crate::ts::types::constructor_type::FormatTsConstructorType;
+use crate::ts::types::function_type::FormatTsFunctionType;
+use crate::ts::types::indexed_access_type::FormatTsIndexedAccessType;
+use crate::ts::types::infer_type::FormatTsInferType;
+use crate::ts::types::intersection_type::FormatTsIntersectionType;
+use crate::ts::types::mapped_type::FormatTsMappedType;
+use crate::ts::types::never_type::FormatTsNeverType;
+use crate::ts::types::non_primitive_type::FormatTsNonPrimitiveType;
+use crate::ts::types::null_literal_type::FormatTsNullLiteralType;
+use crate::ts::types::number_literal_type::FormatTsNumberLiteralType;
+use crate::ts::types::number_type::FormatTsNumberType;
+use crate::ts::types::object_type::FormatTsObjectType;
+use crate::ts::types::parenthesized_type::FormatTsParenthesizedType;
+use crate::ts::types::reference_type::FormatTsReferenceType;
+use crate::ts::types::string_literal_type::FormatTsStringLiteralType;
+use crate::ts::types::string_type::FormatTsStringType;
+use crate::ts::types::symbol_type::FormatTsSymbolType;
+use crate::ts::types::this_type::FormatTsThisType;
+use crate::ts::types::tuple_type::FormatTsTupleType;
+use crate::ts::types::type_operator_type::FormatTsTypeOperatorType;
+use crate::ts::types::typeof_type::FormatTsTypeofType;
+use crate::ts::types::undefined_type::FormatTsUndefinedType;
+use crate::ts::types::union_type::FormatTsUnionType;
+use crate::ts::types::unknown_type::FormatTsUnknownType;
+use crate::ts::types::void_type::FormatTsVoidType;
 use crate::utils::should_hug_type;
-use rome_formatter::write;
-use rome_js_syntax::{JsLanguage, TsType, TsUnionTypeVariantList};
+use crate::JsCommentStyle;
+use rome_formatter::{comments::CommentStyle, write};
+use rome_js_syntax::{JsLanguage, TsType, TsUnionType, TsUnionTypeVariantList};
 use rome_rowan::{AstSeparatedElement, AstSeparatedList};
 
 #[derive(Debug, Clone, Default)]
@@ -30,6 +65,7 @@ impl FormatRule<TsUnionTypeVariantList> for FormatTsUnionTypeVariantList {
                     .enumerate()
                     .map(|(index, item)| FormatTypeVariant {
                         last: index == last_index,
+                        list: node,
                         element: item,
                         should_hug,
                     }),
@@ -38,22 +74,105 @@ impl FormatRule<TsUnionTypeVariantList> for FormatTsUnionTypeVariantList {
     }
 }
 
-pub struct FormatTypeVariant {
-    pub last: bool,
-    pub should_hug: bool,
-    pub element: AstSeparatedElement<JsLanguage, TsType>,
+pub struct FormatTypeVariant<'a> {
+    last: bool,
+    should_hug: bool,
+    element: AstSeparatedElement<JsLanguage, TsType>,
+    list: &'a TsUnionTypeVariantList,
 }
 
-impl Format<JsFormatContext> for FormatTypeVariant {
+impl Format<JsFormatContext> for FormatTypeVariant<'_> {
     fn fmt(&self, f: &mut JsFormatter) -> FormatResult<()> {
         let separator = self.element.trailing_separator()?;
 
+        let node = self.element.node()?;
+
+        let is_suppressed = is_type_suppressed(node, self.list, f.comments());
+
+        // This is a hack: It by passes the regular format node to only format the node without its comments.
+        let format_node = format_with(|f: &mut JsFormatter| {
+            if is_suppressed {
+                write!(f, [format_suppressed_node(node.syntax()).skip_comments()])
+            } else {
+                match node {
+                    TsType::TsAnyType(ty) => FormatTsAnyType::default().fmt_node(ty, f),
+                    TsType::TsArrayType(ty) => FormatTsArrayType::default().fmt_node(ty, f),
+                    TsType::TsBigIntLiteralType(ty) => {
+                        FormatTsBigIntLiteralType::default().fmt_node(ty, f)
+                    }
+                    TsType::TsBigintType(ty) => FormatTsBigintType::default().fmt_node(ty, f),
+                    TsType::TsBooleanLiteralType(ty) => {
+                        FormatTsBooleanLiteralType::default().fmt_node(ty, f)
+                    }
+                    TsType::TsBooleanType(ty) => FormatTsBooleanType::default().fmt_node(ty, f),
+                    TsType::TsConditionalType(ty) => {
+                        FormatTsConditionalType::default().fmt_node(ty, f)
+                    }
+                    TsType::TsConstructorType(ty) => {
+                        FormatTsConstructorType::default().fmt_node(ty, f)
+                    }
+                    TsType::TsFunctionType(ty) => FormatTsFunctionType::default().fmt_node(ty, f),
+                    TsType::TsImportType(ty) => FormatTsImportType::default().fmt_node(ty, f),
+                    TsType::TsIndexedAccessType(ty) => {
+                        FormatTsIndexedAccessType::default().fmt_node(ty, f)
+                    }
+                    TsType::TsInferType(ty) => FormatTsInferType::default().fmt_node(ty, f),
+                    TsType::TsIntersectionType(ty) => {
+                        FormatTsIntersectionType::default().fmt_node(ty, f)
+                    }
+                    TsType::TsMappedType(ty) => FormatTsMappedType::default().fmt_node(ty, f),
+                    TsType::TsNeverType(ty) => FormatTsNeverType::default().fmt_node(ty, f),
+                    TsType::TsNonPrimitiveType(ty) => {
+                        FormatTsNonPrimitiveType::default().fmt_node(ty, f)
+                    }
+                    TsType::TsNullLiteralType(ty) => {
+                        FormatTsNullLiteralType::default().fmt_node(ty, f)
+                    }
+                    TsType::TsNumberLiteralType(ty) => {
+                        FormatTsNumberLiteralType::default().fmt_node(ty, f)
+                    }
+                    TsType::TsNumberType(ty) => FormatTsNumberType::default().fmt_node(ty, f),
+                    TsType::TsObjectType(ty) => FormatTsObjectType::default().fmt_node(ty, f),
+                    TsType::TsParenthesizedType(ty) => {
+                        FormatTsParenthesizedType::default().fmt_node(ty, f)
+                    }
+                    TsType::TsReferenceType(ty) => FormatTsReferenceType::default().fmt_node(ty, f),
+                    TsType::TsStringLiteralType(ty) => {
+                        FormatTsStringLiteralType::default().fmt_node(ty, f)
+                    }
+                    TsType::TsStringType(ty) => FormatTsStringType::default().fmt_node(ty, f),
+                    TsType::TsSymbolType(ty) => FormatTsSymbolType::default().fmt_node(ty, f),
+                    TsType::TsTemplateLiteralType(ty) => {
+                        FormatTsTemplateLiteralType::default().fmt_node(ty, f)
+                    }
+                    TsType::TsThisType(ty) => FormatTsThisType::default().fmt_node(ty, f),
+                    TsType::TsTupleType(ty) => FormatTsTupleType::default().fmt_node(ty, f),
+                    TsType::TsTypeOperatorType(ty) => {
+                        FormatTsTypeOperatorType::default().fmt_node(ty, f)
+                    }
+                    TsType::TsTypeofType(ty) => FormatTsTypeofType::default().fmt_node(ty, f),
+                    TsType::TsUndefinedType(ty) => FormatTsUndefinedType::default().fmt_node(ty, f),
+                    TsType::TsUnionType(ty) => FormatTsUnionType::default().fmt_node(ty, f),
+                    TsType::TsUnknownType(ty) => FormatTsUnknownType::default().fmt_node(ty, f),
+                    TsType::TsVoidType(ty) => FormatTsVoidType::default().fmt_node(ty, f),
+                }
+            }
+        });
+
+        write!(f, [format_leading_comments(node.syntax())])?;
+
         if self.should_hug {
-            write!(f, [self.element.node().format()])?;
+            write!(f, [format_node])?;
         } else {
-            write!(f, [align(2, &self.element.node().format())])?;
+            write!(f, [align(2, &format_node)])?;
         }
 
+        if !is_suppressed {
+            write!(f, [format_dangling_comments(node.syntax())])?;
+        }
+
+        write!(f, [format_trailing_comments(node.syntax())])?;
+
         if let Some(token) = separator {
             if self.last {
                 write!(f, [format_removed(token)])?;
@@ -70,3 +189,55 @@ impl Format<JsFormatContext> for FormatTypeVariant {
         Ok(())
     }
 }
+
+fn is_type_suppressed(ty: &TsType, list: &TsUnionTypeVariantList, comments: &JsComments) -> bool {
+    comments.mark_suppression_checked(ty.syntax());
+
+    if let TsType::TsUnionType(union) = ty {
+        // If the union isn't empty, than the suppression applies to the first variant
+        if !union.types().is_empty() {
+            return false;
+        }
+    }
+
+    // Otherwise check if the node has a suppression in its leading or dangling comments
+    // before then checking the previous variants trailing "OwnLine" comments (comments that are on their own line)
+    let leading_dangling = comments
+        .leading_comments(ty.syntax())
+        .iter()
+        .chain(comments.dangling_comments(ty.syntax()));
+
+    for comment in leading_dangling {
+        if JsCommentStyle::is_suppression(comment.piece().text()) {
+            return true;
+        }
+    }
+
+    for comment in comments
+        .trailing_comments(ty.syntax())
+        .iter()
+        .take_while(|comment| comment.lines_before() == 0)
+    {
+        if JsCommentStyle::is_suppression(comment.piece().text()) {
+            return true;
+        }
+    }
+
+    // Test if the preceding node as a trailing own line comment that is a suppression
+    if let Some(preceding_variant) = ty.syntax().prev_sibling() {
+        comments
+            .trailing_comments(&preceding_variant)
+            .iter()
+            .skip_while(|comment| comment.lines_before() == 0)
+            .any(|comment| JsCommentStyle::is_suppression(comment.piece().text()))
+    }
+    // If this is the first variant, then see if the union has a leading suppression comment.
+    else if let Some(union) = list.parent::<TsUnionType>() {
+        comments
+            .leading_comments(union.syntax())
+            .iter()
+            .any(|comment| JsCommentStyle::is_suppression(comment.piece().text()))
+    } else {
+        false
+    }
+}
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 94780fba316..041cb076c57 100644
--- a/crates/rome_js_formatter/src/ts/types/mapped_type.rs
+++ b/crates/rome_js_formatter/src/ts/types/mapped_type.rs
@@ -1,7 +1,7 @@
 use crate::prelude::*;
-use crate::utils::FormatWithSemicolon;
 
 use crate::parentheses::NeedsParentheses;
+use rome_formatter::trivia::FormatLeadingComments;
 use rome_formatter::{format_args, write};
 use rome_js_syntax::{JsSyntaxNode, TsMappedType, TsMappedTypeFields};
 
@@ -25,39 +25,76 @@ impl FormatNodeRule<TsMappedType> for FormatTsMappedType {
             r_curly_token,
         } = node.as_fields();
 
+        let property_name = property_name?;
+
+        let should_expand = node
+            .syntax()
+            .tokens()
+            .flat_map(|token| {
+                token
+                    .leading_trivia()
+                    .pieces()
+                    .chain(token.trailing_trivia().pieces())
+            })
+            .any(|piece| piece.is_newline());
+
+        let format_semi = format_with(|f| {
+            if let Some(semi) = &semicolon_token {
+                write!(f, [semi.format()])
+            } else {
+                write!(f, [text(";")])
+            }
+        });
+
+        let comments = f.comments().clone();
+        let dangling_comments = comments.dangling_comments(node.syntax());
+        let type_annotation_has_leading_comment =
+            mapped_type.as_ref().map_or(false, |annotation| {
+                comments.has_leading_comments(annotation.syntax())
+            });
+
         write!(
             f,
-            [format_delimited(
-                &l_curly_token?,
-                &FormatWithSemicolon::new(
-                    &format_args!(
-                        readonly_modifier
-                            .format()
-                            .with_or_empty(|readonly, f| write![f, [readonly, space()]]),
+            [
+                &l_curly_token.format(),
+                group(&indent(&format_args!(
+                    soft_line_break_or_space(),
+                    readonly_modifier
+                        .format()
+                        .with_or_empty(|readonly, f| write![f, [readonly, space()]]),
+                    FormatLeadingComments::Comments(dangling_comments),
+                    group(&format_args![
                         l_brack_token.format(),
                         property_name.format(),
                         space(),
                         in_token.format(),
-                        space(),
-                        keys_type.format(),
-                        as_clause
-                            .format()
-                            .with_or_empty(|clause, f| write![f, [space(), clause]]),
+                        soft_line_indent_or_space(&format_args![
+                            keys_type.format(),
+                            as_clause.as_ref().map(|_| space()),
+                            as_clause.format(),
+                        ]),
                         r_brack_token.format(),
-                        optional_modifier.format(),
-                        mapped_type.format(),
-                    ),
-                    semicolon_token.as_ref(),
-                ),
-                &r_curly_token?,
-            )
-            .block_indent()]
+                    ]),
+                    optional_modifier.format(),
+                    type_annotation_has_leading_comment.then_some(space()),
+                    mapped_type.format(),
+                    if_group_breaks(&format_semi)
+                )))
+                .should_expand(should_expand),
+                soft_line_break_or_space(),
+                r_curly_token.format(),
+            ]
         )
     }
 
     fn needs_parentheses(&self, item: &TsMappedType) -> bool {
         item.needs_parentheses()
     }
+
+    fn fmt_dangling_comments(&self, _: &TsMappedType, _: &mut JsFormatter) -> FormatResult<()> {
+        // Handled inside of `fmt_fields`
+        Ok(())
+    }
 }
 
 impl NeedsParentheses for TsMappedType {
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 34023eefa36..5c485d3344c 100644
--- a/crates/rome_js_formatter/src/ts/types/object_type.rs
+++ b/crates/rome_js_formatter/src/ts/types/object_type.rs
@@ -15,6 +15,11 @@ impl FormatNodeRule<TsObjectType> for FormatTsObjectType {
     fn needs_parentheses(&self, item: &TsObjectType) -> bool {
         item.needs_parentheses()
     }
+
+    fn fmt_dangling_comments(&self, _: &TsObjectType, _: &mut JsFormatter) -> FormatResult<()> {
+        // Formatted inside of `JsObjectLike`
+        Ok(())
+    }
 }
 
 impl NeedsParentheses for TsObjectType {
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 cdaaae84963..a4d2c1eb203 100644
--- a/crates/rome_js_formatter/src/ts/types/tuple_type.rs
+++ b/crates/rome_js_formatter/src/ts/types/tuple_type.rs
@@ -15,18 +15,28 @@ impl FormatNodeRule<TsTupleType> for FormatTsTupleType {
             r_brack_token,
         } = node.as_fields();
 
-        write!(
-            f,
-            [
-                format_delimited(&l_brack_token?, &elements.format(), &r_brack_token?,)
-                    .soft_block_indent()
-            ]
-        )
+        write!(f, [l_brack_token.format(),])?;
+
+        if elements.is_empty() {
+            write!(
+                f,
+                [format_dangling_comments(node.syntax()).with_soft_block_indent()]
+            )?;
+        } else {
+            write!(f, [group(&soft_block_indent(&elements.format())),])?;
+        }
+
+        write!(f, [r_brack_token.format(),])
     }
 
     fn needs_parentheses(&self, item: &TsTupleType) -> bool {
         item.needs_parentheses()
     }
+
+    fn fmt_dangling_comments(&self, _: &TsTupleType, _: &mut JsFormatter) -> FormatResult<()> {
+        // Handled inside of `fmt_fields`
+        Ok(())
+    }
 }
 
 impl NeedsParentheses for TsTupleType {
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 454223ac2a9..0213e348291 100644
--- a/crates/rome_js_formatter/src/ts/types/union_type.rs
+++ b/crates/rome_js_formatter/src/ts/types/union_type.rs
@@ -1,8 +1,8 @@
 use crate::parentheses::NeedsParentheses;
 use crate::prelude::*;
 use crate::utils::{
-    has_leading_own_line_comment, should_hug_type, union_or_intersection_type_needs_parentheses,
-    FormatTypeMemberSeparator, TsIntersectionOrUnionTypeList,
+    should_hug_type, union_or_intersection_type_needs_parentheses, FormatTypeMemberSeparator,
+    TsIntersectionOrUnionTypeList,
 };
 use rome_formatter::{format_args, write, Buffer};
 use rome_js_syntax::{JsSyntaxKind, JsSyntaxToken, TsTupleTypeElementList, TsUnionType};
@@ -35,14 +35,14 @@ impl FormatNodeRule<TsUnionType> for FormatTsUnionType {
             );
         }
 
-        let has_leading_own_line_comment = has_leading_own_line_comment(node.syntax());
+        let has_leading_comments = f.comments().has_leading_comments(node.syntax());
 
         let should_indent = {
             let parent_kind = node.syntax().parent().map(|p| p.kind());
 
             // These parents have indent for their content, so we don't need to indent here
             !match parent_kind {
-                Some(JsSyntaxKind::TS_TYPE_ALIAS_DECLARATION) => has_leading_own_line_comment,
+                Some(JsSyntaxKind::TS_TYPE_ALIAS_DECLARATION) => has_leading_comments,
                 parent_kind => {
                     matches!(
                         parent_kind,
@@ -58,14 +58,17 @@ impl FormatNodeRule<TsUnionType> for FormatTsUnionType {
         };
 
         let types = format_with(|f| {
+            if has_leading_comments {
+                write!(f, [soft_line_break()])?;
+            }
+
             write!(
                 f,
                 [
                     FormatTypeSetLeadingSeparator {
-                        separator: JsSyntaxKind::PIPE,
+                        separator: "|",
                         leading_separator: leading_separator_token.as_ref(),
-                        leading_soft_line_break_or_space: should_indent
-                            && !has_leading_own_line_comment,
+                        leading_soft_line_break_or_space: should_indent && !has_leading_comments,
                     },
                     types.format()
                 ]
@@ -110,6 +113,17 @@ impl FormatNodeRule<TsUnionType> for FormatTsUnionType {
     fn needs_parentheses(&self, item: &TsUnionType) -> bool {
         item.needs_parentheses()
     }
+
+    fn is_suppressed(&self, node: &TsUnionType, f: &JsFormatter) -> bool {
+        f.comments().mark_suppression_checked(node.syntax());
+
+        if node.types().is_empty() {
+            f.comments().is_suppressed(node.syntax())
+        } else {
+            // Suppression applies to first variant
+            false
+        }
+    }
 }
 
 impl NeedsParentheses for TsUnionType {
@@ -123,7 +137,7 @@ impl NeedsParentheses for TsUnionType {
 }
 
 pub struct FormatTypeSetLeadingSeparator<'a> {
-    separator: JsSyntaxKind,
+    separator: &'static str,
     leading_separator: Option<&'a JsSyntaxToken>,
     leading_soft_line_break_or_space: bool,
 }
@@ -145,7 +159,7 @@ impl Format<JsFormatContext> for FormatTypeSetLeadingSeparator<'_> {
                     if self.leading_soft_line_break_or_space {
                         write!(f, [soft_line_break_or_space()])?;
                     }
-                    write!(f, [format_inserted(self.separator), space()])
+                    write!(f, [text(self.separator), space()])
                 });
 
                 write!(f, [if_group_breaks(&content)])
diff --git a/crates/rome_js_formatter/src/utils/array.rs b/crates/rome_js_formatter/src/utils/array.rs
index 3b18f77e840..5a23bffd88a 100644
--- a/crates/rome_js_formatter/src/utils/array.rs
+++ b/crates/rome_js_formatter/src/utils/array.rs
@@ -4,7 +4,7 @@ use crate::AsFormat;
 use rome_formatter::write;
 use rome_js_syntax::{
     JsAnyArrayAssignmentPatternElement, JsAnyArrayBindingPatternElement, JsAnyArrayElement,
-    JsLanguage, JsSyntaxKind,
+    JsLanguage,
 };
 use rome_rowan::{AstNode, AstSeparatedList};
 
@@ -42,12 +42,12 @@ where
                     // In forced separator mode or if this element is not the last in the list, print the separator
                     match element.trailing_separator()? {
                         Some(trailing) => write!(f, [trailing.format()])?,
-                        None => format_inserted(JsSyntaxKind::COMMA).fmt(f)?,
+                        None => text(",").fmt(f)?,
                     };
                 } else if let Some(separator) = element.trailing_separator()? {
                     write!(f, [format_only_if_breaks(separator, &separator.format())])?;
                 } else {
-                    write!(f, [if_group_breaks(&format_inserted(JsSyntaxKind::COMMA))])?;
+                    write!(f, [if_group_breaks(&text(","))])?;
                 };
 
                 Ok(())
diff --git a/crates/rome_js_formatter/src/utils/assignment_like.rs b/crates/rome_js_formatter/src/utils/assignment_like.rs
index 86faf3821ad..2d265ddc2d8 100644
--- a/crates/rome_js_formatter/src/utils/assignment_like.rs
+++ b/crates/rome_js_formatter/src/utils/assignment_like.rs
@@ -1,9 +1,8 @@
 use crate::js::auxiliary::initializer_clause::FormatJsInitializerClauseOptions;
-use crate::parentheses::get_expression_left_side;
 use crate::prelude::*;
 use crate::utils::member_chain::is_member_call_chain;
 use crate::utils::object::write_member_name;
-use crate::utils::{JsAnyBinaryLikeExpression, JsAnyBinaryLikeLeftExpression};
+use crate::utils::JsAnyBinaryLikeExpression;
 use rome_formatter::{format_args, write, CstFormatContext, FormatOptions, VecBuffer};
 use rome_js_syntax::JsAnyLiteralExpression;
 use rome_js_syntax::{
@@ -19,8 +18,6 @@ use rome_js_syntax::{
 use rome_rowan::{declare_node_union, AstNode, SyntaxResult};
 use std::iter;
 
-use super::has_leading_own_line_comment;
-
 declare_node_union! {
     pub(crate) JsAnyAssignmentLike =
         JsPropertyObjectMember |
@@ -620,7 +617,7 @@ impl JsAnyAssignmentLike {
             return Ok(AssignmentLikeLayout::BreakLeftHandSide);
         }
 
-        if self.should_break_after_operator(&right)? {
+        if self.should_break_after_operator(&right, f.context().comments())? {
             return Ok(AssignmentLikeLayout::BreakAfterOperator);
         }
 
@@ -818,11 +815,22 @@ impl JsAnyAssignmentLike {
     ///
     /// This function is small wrapper around [should_break_after_operator] because it has to work
     /// for nodes that belong to TypeScript too.
-    fn should_break_after_operator(&self, right: &RightAssignmentLike) -> SyntaxResult<bool> {
-        let result = if let Some(expression) = right.as_expression() {
-            should_break_after_operator(&expression)?
-        } else {
-            has_leading_own_line_comment(right.syntax())
+    fn should_break_after_operator(
+        &self,
+        right: &RightAssignmentLike,
+        comments: &JsComments,
+    ) -> SyntaxResult<bool> {
+        let result = match right {
+            RightAssignmentLike::JsAnyExpression(expression) => {
+                should_break_after_operator(expression, comments)?
+            }
+            RightAssignmentLike::JsInitializerClause(initializer) => {
+                should_break_after_operator(&initializer.expression()?, comments)?
+            }
+            RightAssignmentLike::TsType(TsType::TsUnionType(ty)) => {
+                comments.has_leading_comments(ty.syntax())
+            }
+            right => comments.has_leading_own_line_comment(right.syntax()),
         };
 
         Ok(result)
@@ -830,22 +838,14 @@ impl JsAnyAssignmentLike {
 }
 
 /// Checks if the function is entitled to be printed with layout [AssignmentLikeLayout::BreakAfterOperator]
-pub(crate) fn should_break_after_operator(right: &JsAnyExpression) -> SyntaxResult<bool> {
-    // Traverse from the right expression to the left most node and check if any has a leading comment
-    // that causes a line break.
-    let mut current: JsAnyBinaryLikeLeftExpression = right.clone().into();
-    loop {
-        if has_leading_own_line_comment(current.syntax()) {
-            return Ok(true);
-        }
-
-        if let JsAnyBinaryLikeLeftExpression::JsAnyExpression(expression) = current {
-            if let Some(left) = get_expression_left_side(&expression) {
-                current = left;
-                continue;
-            }
-        }
-        break;
+pub(crate) fn should_break_after_operator(
+    right: &JsAnyExpression,
+    comments: &JsComments,
+) -> SyntaxResult<bool> {
+    if comments.has_leading_own_line_comment(right.syntax())
+        && !matches!(right, JsAnyExpression::JsxTagExpression(_))
+    {
+        return Ok(true);
     }
 
     let result = match right {
@@ -1050,7 +1050,9 @@ fn is_poorly_breakable_member_or_call_chain(
         let is_breakable_call = match args.len() {
             0 => false,
             1 => match args.iter().next() {
-                Some(first_argument) => !is_short_argument(first_argument?, threshold)?,
+                Some(first_argument) => {
+                    !is_short_argument(first_argument?, threshold, f.context().comments())?
+                }
                 None => false,
             },
             _ => true,
@@ -1077,8 +1079,12 @@ fn is_poorly_breakable_member_or_call_chain(
 /// We need it to decide if `JsCallExpression` with the argument is breakable or not
 /// If the argument is short the function call isn't breakable
 /// [Prettier applies]: https://github.com/prettier/prettier/blob/a043ac0d733c4d53f980aa73807a63fc914f23bd/src/language-js/print/assignment.js#L374
-fn is_short_argument(argument: JsAnyCallArgument, threshold: u16) -> SyntaxResult<bool> {
-    if argument.syntax().has_comments_direct() {
+fn is_short_argument(
+    argument: JsAnyCallArgument,
+    threshold: u16,
+    comments: &JsComments,
+) -> SyntaxResult<bool> {
+    if comments.has_comments(argument.syntax()) {
         return Ok(false);
     }
 
@@ -1089,7 +1095,7 @@ fn is_short_argument(argument: JsAnyCallArgument, threshold: u16) -> SyntaxResul
                 identifier.name()?.value_token()?.text_trimmed().len() <= threshold as usize
             }
             JsAnyExpression::JsUnaryExpression(unary_expression) => {
-                let has_comments = unary_expression.argument()?.syntax().has_comments_direct();
+                let has_comments = comments.has_comments(unary_expression.argument()?.syntax());
 
                 unary_expression.is_signed_numeric_literal()? && !has_comments
             }
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 f114c01825a..e22948e207a 100644
--- a/crates/rome_js_formatter/src/utils/binary_like_expression.rs
+++ b/crates/rome_js_formatter/src/utils/binary_like_expression.rs
@@ -54,7 +54,6 @@
 //! and right side of each Right side.
 
 use crate::prelude::*;
-use crate::utils::{has_token_trailing_line_comment, has_trailing_line_comment};
 use rome_formatter::{format_args, write, Buffer, CstFormatContext};
 use rome_js_syntax::{
     JsAnyExpression, JsAnyInProperty, JsBinaryExpression, JsBinaryOperator, JsDoWhileStatement,
@@ -73,8 +72,6 @@ use std::fmt::Debug;
 use std::hash::Hash;
 use std::iter::FusedIterator;
 
-use super::has_leading_own_line_comment;
-
 declare_node_union! {
     pub(crate) JsAnyBinaryLikeExpression = JsLogicalExpression | JsBinaryExpression | JsInstanceofExpression | JsInExpression
 }
@@ -197,6 +194,7 @@ fn split_into_left_and_right_sides(
                 }
             }
             VisitEvent::Exit(expression) => items.push(BinaryLeftOrRightSide::Right {
+                print_parent_comments: expression.syntax() != root.syntax(),
                 parent: expression,
                 inside_condition,
             }),
@@ -268,6 +266,10 @@ enum BinaryLeftOrRightSide {
         parent: JsAnyBinaryLikeExpression,
         /// Is the parent the condition of a `if` / `while` / `do-while` / `for` statement?
         inside_condition: bool,
+
+        /// Indicates if the comments of the parent should be printed or not.
+        /// Must be true if `parent` isn't the root `JsAnyBinaryLike` for which `format` is called.
+        print_parent_comments: bool,
     },
 }
 
@@ -297,6 +299,7 @@ impl Format<JsFormatContext> for BinaryLeftOrRightSide {
             BinaryLeftOrRightSide::Right {
                 parent: binary_like_expression,
                 inside_condition: inside_parenthesis,
+                print_parent_comments,
             } => {
                 // It's only possible to suppress the formatting of the whole binary expression formatting OR
                 // the formatting of the right hand side value but not of a nested binary expression.
@@ -341,13 +344,12 @@ impl Format<JsFormatContext> for BinaryLeftOrRightSide {
                 let right_has_same_kind =
                     is_same_binary_expression_kind(binary_like_expression, right.syntax());
 
-                let should_break = {
-                    if has_token_trailing_line_comment(&operator_token) {
-                        true
-                    } else {
-                        has_leading_own_line_comment(binary_like_expression.left()?.syntax())
-                    }
-                };
+                let should_break = f
+                    .context()
+                    .comments()
+                    .trailing_comments(binary_like_expression.left()?.syntax())
+                    .iter()
+                    .any(|comment| comment.kind().is_line());
 
                 let should_group = !(parent_has_same_kind
                     || left_has_same_kind
@@ -358,20 +360,24 @@ impl Format<JsFormatContext> for BinaryLeftOrRightSide {
                             JsAnyBinaryLikeExpression::JsLogicalExpression(_)
                         )));
 
+                if *print_parent_comments {
+                    write!(
+                        f,
+                        [format_leading_comments(binary_like_expression.syntax())]
+                    )?;
+                }
+
                 if !should_break && should_group {
                     write!(f, [group(&operator_and_right_expression)])?;
                 } else {
                     write!(f, [operator_and_right_expression])?;
                 }
 
-                // This is not ideal but it fixes an instability issue when the right hand side has a trailing line comment
-                // `a && b // comment` -> `a &&\n b; // comment` (see how the comment moved after the `;`)
-                if has_trailing_line_comment(right.syntax())
-                    && parent.map_or(false, |parent| {
-                        parent.kind() == JsSyntaxKind::JS_EXPRESSION_STATEMENT
-                    })
-                {
-                    write!(f, [line_suffix_boundary()])?;
+                if *print_parent_comments {
+                    write!(
+                        f,
+                        [format_trailing_comments(binary_like_expression.syntax())]
+                    )?;
                 }
 
                 Ok(())
diff --git a/crates/rome_js_formatter/src/utils/conditional.rs b/crates/rome_js_formatter/src/utils/conditional.rs
index 0bf70651994..a8df8e3179b 100644
--- a/crates/rome_js_formatter/src/utils/conditional.rs
+++ b/crates/rome_js_formatter/src/utils/conditional.rs
@@ -1,6 +1,7 @@
 use crate::prelude::*;
 use rome_formatter::{
-    write, FormatContext, FormatOwnedWithRule, FormatRefWithRule, FormatRuleWithOptions,
+    write, CstFormatContext, FormatContext, FormatOwnedWithRule, FormatRefWithRule,
+    FormatRuleWithOptions,
 };
 
 use crate::{AsFormat, IntoFormat};
@@ -187,8 +188,7 @@ impl FormatRule<JsAnyConditional> for FormatJsAnyConditionalRule {
                 write!(f, [soft_line_break()])?;
             }
 
-            // Make sure that line suffix comments to not escape
-            write!(f, [line_suffix_boundary()])
+            Ok(())
         });
 
         let grouped = format_with(|f| {
@@ -199,9 +199,39 @@ impl FormatRule<JsAnyConditional> for FormatJsAnyConditionalRule {
             }
         });
 
+        let has_multiline_comment = {
+            let comments = f.context().comments();
+
+            let has_block_comment = |syntax: &JsSyntaxNode| {
+                comments
+                    .leading_trailing_comments(syntax)
+                    .any(|comment| comment.kind().is_block())
+            };
+
+            let test_has_block_comments = match conditional {
+                JsAnyConditional::JsConditionalExpression(expression) => {
+                    has_block_comment(expression.test()?.syntax())
+                }
+                JsAnyConditional::TsConditionalType(ty) => {
+                    has_block_comment(ty.check_type()?.syntax())
+                        || has_block_comment(ty.extends_type()?.syntax())
+                }
+            };
+
+            test_has_block_comments
+                || has_block_comment(consequent.syntax())
+                || has_block_comment(alternate.syntax())
+        };
+
         if layout.is_nested_test() || should_extra_indent {
-            group(&soft_block_indent(&grouped)).fmt(f)
+            group(&soft_block_indent(&grouped))
+                .should_expand(has_multiline_comment)
+                .fmt(f)
         } else {
+            if has_multiline_comment {
+                write!(f, [expand_parent()])?;
+            }
+
             grouped.fmt(f)
         }
     }
@@ -660,7 +690,7 @@ impl JsAnyConditional {
         }
     }
 
-    fn question_mark_token(&self) -> SyntaxResult<JsSyntaxToken> {
+    pub(crate) fn question_mark_token(&self) -> SyntaxResult<JsSyntaxToken> {
         match self {
             JsAnyConditional::JsConditionalExpression(conditional) => {
                 conditional.question_mark_token()
@@ -680,7 +710,7 @@ impl JsAnyConditional {
         }
     }
 
-    fn colon_token(&self) -> SyntaxResult<JsSyntaxToken> {
+    pub(crate) fn colon_token(&self) -> SyntaxResult<JsSyntaxToken> {
         match self {
             JsAnyConditional::JsConditionalExpression(conditional) => conditional.colon_token(),
             JsAnyConditional::TsConditionalType(conditional) => conditional.colon_token(),
diff --git a/crates/rome_js_formatter/src/utils/format_class.rs b/crates/rome_js_formatter/src/utils/format_class.rs
index d2834b209f6..d9ada0dbbad 100644
--- a/crates/rome_js_formatter/src/utils/format_class.rs
+++ b/crates/rome_js_formatter/src/utils/format_class.rs
@@ -1,5 +1,5 @@
 use crate::prelude::*;
-use rome_formatter::write;
+use rome_formatter::{format_args, write};
 use rome_js_syntax::JsAnyClass;
 
 pub struct FormatClass<'a> {
@@ -7,21 +7,21 @@ pub struct FormatClass<'a> {
 }
 
 impl FormatClass<'_> {
-    fn should_group(&self) -> FormatResult<bool> {
+    fn should_group(&self, comments: &JsComments) -> FormatResult<bool> {
         if let Some(id) = self.class.id()? {
-            if id.syntax().has_trailing_comments() {
+            if comments.has_trailing_comments(id.syntax()) {
                 return Ok(true);
             }
         }
 
         if let Some(type_parameters) = self.class.type_parameters() {
-            if type_parameters.syntax().has_trailing_comments() {
+            if comments.has_trailing_comments(type_parameters.syntax()) {
                 return Ok(true);
             }
         }
 
         if let Some(extends) = self.class.extends_clause() {
-            if extends.syntax().has_trailing_comments() {
+            if comments.has_trailing_comments(extends.syntax()) {
                 return Ok(true);
             }
         }
@@ -50,7 +50,7 @@ impl Format<JsFormatContext> for FormatClass<'_> {
         let class_token = self.class.class_token()?;
         let members = self.class.members();
 
-        let group_mode = self.should_group()?;
+        let group_mode = self.should_group(f.comments())?;
 
         if let Some(abstract_token) = abstract_token {
             write!(f, [abstract_token.format(), space()])?;
@@ -58,39 +58,74 @@ impl Format<JsFormatContext> for FormatClass<'_> {
 
         write!(f, [class_token.format()])?;
 
+        let indent_only_heritage = type_parameters.as_ref().map_or(false, |type_parameters| {
+            !f.comments()
+                .has_trailing_line_comment(type_parameters.syntax())
+        }) && !(extends.is_some() && implements_clause.is_some());
+
+        let type_parameters_id = if indent_only_heritage && implements_clause.is_some() {
+            Some(f.group_id("type_parameters"))
+        } else {
+            None
+        };
+
         let head = format_with(|f| {
             if let Some(id) = &id {
                 write!(f, [space(), id.format()])?;
             }
 
-            write!(f, [type_parameters.format()])?;
+            if let Some(type_parameters) = &type_parameters {
+                write!(
+                    f,
+                    [type_parameters.format().with_options(type_parameters_id)]
+                )?;
+            }
+
+            Ok(())
+        });
 
+        let format_heritage_clauses = format_with(|f| {
             if let Some(extends) = &extends {
                 if group_mode {
-                    write!(f, [soft_line_break_or_space()])?;
+                    write!(f, [soft_line_break_or_space(), group(&extends.format())])?;
                 } else {
-                    write!(f, [space()])?;
+                    write!(f, [space(), extends.format()])?;
                 }
-
-                write!(f, [extends.format()])?;
             }
 
             if let Some(implements_clause) = &implements_clause {
-                write!(f, [soft_line_break_or_space(), implements_clause.format()])?;
+                if indent_only_heritage {
+                    write!(
+                        f,
+                        [
+                            if_group_breaks(&space()).with_group_id(type_parameters_id),
+                            if_group_fits_on_line(&soft_line_break_or_space())
+                                .with_group_id(type_parameters_id)
+                        ]
+                    )?;
+                } else {
+                    write!(f, [soft_line_break_or_space()])?;
+                }
+
+                write!(f, [implements_clause.format()])?;
             }
 
             Ok(())
         });
 
         if group_mode {
-            let heritage_id = f.group_id("heritageGroup");
+            let indented = format_with(|f| {
+                if indent_only_heritage {
+                    write!(f, [head, indent(&format_heritage_clauses)])
+                } else {
+                    write!(f, [indent(&format_args![head, format_heritage_clauses])])
+                }
+            });
 
+            let heritage_id = f.group_id("heritageGroup");
             write!(
                 f,
-                [
-                    group(&indent(&head)).with_group_id(Some(heritage_id)),
-                    space(),
-                ]
+                [group(&indented).with_group_id(Some(heritage_id)), space()]
             )?;
 
             if !members.is_empty() {
@@ -100,17 +135,27 @@ impl Format<JsFormatContext> for FormatClass<'_> {
                 )?;
             }
         } else {
-            write!(f, [head, space()])?;
+            write!(f, [head, format_heritage_clauses, space()])?;
         }
 
-        write![
-            f,
-            [format_delimited(
-                &self.class.l_curly_token()?,
-                &members.format(),
-                &self.class.r_curly_token()?
+        if members.is_empty() {
+            write!(
+                f,
+                [
+                    self.class.l_curly_token().format(),
+                    format_dangling_comments(self.class.syntax()).with_block_indent(),
+                    self.class.r_curly_token().format()
+                ]
             )
-            .block_indent()]
-        ]
+        } else {
+            write![
+                f,
+                [
+                    self.class.l_curly_token().format(),
+                    block_indent(&members.format()),
+                    self.class.r_curly_token().format()
+                ]
+            ]
+        }
     }
 }
diff --git a/crates/rome_js_formatter/src/utils/jsx.rs b/crates/rome_js_formatter/src/utils/jsx.rs
index 39e849c0c64..bb91647c55a 100644
--- a/crates/rome_js_formatter/src/utils/jsx.rs
+++ b/crates/rome_js_formatter/src/utils/jsx.rs
@@ -1,11 +1,13 @@
 use crate::context::QuoteStyle;
 use crate::prelude::*;
-use rome_formatter::{format_args, write};
+use crate::JsCommentStyle;
+use rome_formatter::{comments::CommentStyle, format_args, write};
 use rome_js_syntax::{
     JsAnyExpression, JsAnyLiteralExpression, JsComputedMemberExpression, JsStaticMemberExpression,
-    JsSyntaxKind, JsxAnyChild, JsxExpressionChild, JsxTagExpression, TextLen,
+    JsSyntaxKind, JsxAnyChild, JsxAnyTag, JsxChildList, JsxExpressionChild, JsxTagExpression,
+    JsxText, TextLen,
 };
-use rome_rowan::{SyntaxResult, SyntaxTokenText, TextRange, TextSize};
+use rome_rowan::{Direction, SyntaxResult, SyntaxTokenText, TextRange, TextSize};
 use std::iter::{FusedIterator, Peekable};
 use std::str::Chars;
 
@@ -39,6 +41,50 @@ pub fn is_meaningful_jsx_text(text: &str) -> bool {
     !has_newline
 }
 
+/// Tests if a [JsxAnyTag] has a suppression comment or not.
+///
+/// Suppression for [JsxAnyTag] differs from regular nodes if they are inside of a [JsxChildList] because
+/// they can then not be preceded by a comment.
+///
+/// A [JsxAnyTag] inside of a [JsxChildList] is suppressed if its first preceding sibling (that contains meaningful text)
+/// is a [JsxExpressionChild], not containing any expression, with a dangling suppression comment.
+///
+/// ```javascript
+/// <div>
+//   {/* rome-ignore format: reason */}
+//   <div a={  some} />
+//   </div>
+/// ```
+pub(crate) fn is_jsx_suppressed(tag: &JsxAnyTag, comments: &JsComments) -> bool {
+    comments.mark_suppression_checked(tag.syntax());
+
+    match tag.parent::<JsxChildList>() {
+        Some(_) => {
+            let prev_non_empty_text_sibling =
+                tag.syntax()
+                    .siblings(Direction::Prev)
+                    .skip(1)
+                    .find(|sibling| {
+                        if let Some(text) = JsxText::cast_ref(sibling) {
+                            text.value_token()
+                                .map_or(true, |token| is_meaningful_jsx_text(token.text()))
+                        } else {
+                            true
+                        }
+                    });
+
+            match prev_non_empty_text_sibling.and_then(JsxExpressionChild::cast) {
+                Some(child) if child.expression().is_none() => comments
+                    .dangling_comments(child.syntax())
+                    .iter()
+                    .any(|comment| JsCommentStyle::is_suppression(comment.piece().text())),
+                Some(_) | None => false,
+            }
+        }
+        _ => false,
+    }
+}
+
 /// Indicates that an element should always be wrapped in parentheses, should be wrapped
 /// only when it's line broken, or should not be wrapped at all.
 #[derive(Copy, Clone, Debug)]
@@ -142,7 +188,10 @@ impl Format<JsFormatContext> for JsxRawSpace {
     }
 }
 
-pub(crate) fn is_whitespace_jsx_expression(child: &JsxExpressionChild) -> bool {
+pub(crate) fn is_whitespace_jsx_expression(
+    child: &JsxExpressionChild,
+    comments: &JsComments,
+) -> bool {
     match child.expression() {
         Some(JsAnyExpression::JsAnyLiteralExpression(
             JsAnyLiteralExpression::JsStringLiteralExpression(literal),
@@ -152,13 +201,11 @@ pub(crate) fn is_whitespace_jsx_expression(child: &JsxExpressionChild) -> bool {
                 literal.value_token(),
                 child.r_curly_token(),
             ) {
-                (Ok(l_curly_token), Ok(value_token), Ok(r_curly_token)) => {
+                (Ok(_), Ok(value_token), Ok(r_curly_token)) => {
                     let is_empty = matches!(value_token.text_trimmed(), "\" \"" | "' '");
 
-                    let has_comments = l_curly_token.has_trailing_comments()
-                        || r_curly_token.has_leading_comments()
-                        || value_token.has_leading_non_whitespace_trivia()
-                        || value_token.has_trailing_comments();
+                    let has_comments = comments.has_skipped(&r_curly_token)
+                        || comments.has_comments(literal.syntax());
 
                     is_empty && !has_comments
                 }
@@ -169,7 +216,10 @@ pub(crate) fn is_whitespace_jsx_expression(child: &JsxExpressionChild) -> bool {
     }
 }
 
-pub(crate) fn jsx_split_children<I>(children: I) -> SyntaxResult<Vec<JsxChild>>
+pub(crate) fn jsx_split_children<I>(
+    children: I,
+    comments: &JsComments,
+) -> SyntaxResult<Vec<JsxChild>>
 where
     I: IntoIterator<Item = JsxAnyChild>,
 {
@@ -244,7 +294,7 @@ where
             }
 
             JsxAnyChild::JsxExpressionChild(child) => {
-                if is_whitespace_jsx_expression(&child) {
+                if is_whitespace_jsx_expression(&child, comments) {
                     match result.last() {
                         Some(JsxChild::Whitespace) => {
                             // Ignore
@@ -403,6 +453,7 @@ impl FusedIterator for JsxSplitChunksIterator<'_> {}
 mod tests {
     use crate::utils::jsx::{jsx_split_children, JsxChild, JsxSplitChunksIterator, JsxTextChunk};
     use rome_diagnostics::file::FileId;
+    use rome_formatter::comments::Comments;
     use rome_js_parser::parse;
     use rome_js_syntax::{JsxChildList, JsxText, SourceType};
     use rome_rowan::{AstNode, TextSize};
@@ -506,7 +557,7 @@ mod tests {
     fn split_children_words_only() {
         let child_list = parse_jsx_children("a b c");
 
-        let children = jsx_split_children(&child_list).unwrap();
+        let children = jsx_split_children(&child_list, &Comments::default()).unwrap();
 
         assert_eq!(3, children.len());
         assert_word(&children[0], "a");
@@ -518,7 +569,7 @@ mod tests {
     fn split_non_meaningful_text() {
         let child_list = parse_jsx_children("  \n ");
 
-        let children = jsx_split_children(&child_list).unwrap();
+        let children = jsx_split_children(&child_list, &Comments::default()).unwrap();
 
         assert_eq!(children, vec![]);
     }
@@ -527,7 +578,7 @@ mod tests {
     fn split_non_meaningful_leading_multiple_lines() {
         let child_list = parse_jsx_children("  \n  \n ");
 
-        let children = jsx_split_children(&child_list).unwrap();
+        let children = jsx_split_children(&child_list, &Comments::default()).unwrap();
 
         assert_eq!(children, vec![JsxChild::EmptyLine]);
     }
@@ -536,7 +587,7 @@ mod tests {
     fn split_meaningful_whitespace() {
         let child_list = parse_jsx_children("  ");
 
-        let children = jsx_split_children(&child_list).unwrap();
+        let children = jsx_split_children(&child_list, &Comments::default()).unwrap();
 
         assert_eq!(children, vec![JsxChild::Whitespace]);
     }
@@ -545,7 +596,7 @@ mod tests {
     fn split_children_leading_newlines() {
         let child_list = parse_jsx_children("  \n a b");
 
-        let children = jsx_split_children(&child_list).unwrap();
+        let children = jsx_split_children(&child_list, &Comments::default()).unwrap();
 
         assert_eq!(3, children.len());
         assert_eq!(children[0], JsxChild::Newline);
@@ -557,7 +608,7 @@ mod tests {
     fn split_children_trailing_whitespace() {
         let child_list = parse_jsx_children("a b    \t ");
 
-        let children = jsx_split_children(&child_list).unwrap();
+        let children = jsx_split_children(&child_list, &Comments::default()).unwrap();
 
         assert_eq!(3, children.len());
         assert_word(&children[0], "a");
@@ -569,7 +620,7 @@ mod tests {
     fn split_children_trailing_newline() {
         let child_list = parse_jsx_children("a b \n   \t ");
 
-        let children = jsx_split_children(&child_list).unwrap();
+        let children = jsx_split_children(&child_list, &Comments::default()).unwrap();
 
         assert_eq!(3, children.len());
         assert_word(&children[0], "a");
@@ -581,7 +632,7 @@ mod tests {
     fn split_children_empty_expression() {
         let child_list = parse_jsx_children(r#"a{' '}c{" "}"#);
 
-        let children = jsx_split_children(&child_list).unwrap();
+        let children = jsx_split_children(&child_list, &Comments::default()).unwrap();
 
         assert_eq!(
             4,
diff --git a/crates/rome_js_formatter/src/utils/member_chain/chain_member.rs b/crates/rome_js_formatter/src/utils/member_chain/chain_member.rs
index 9b689a2cfed..3d74b494279 100644
--- a/crates/rome_js_formatter/src/utils/member_chain/chain_member.rs
+++ b/crates/rome_js_formatter/src/utils/member_chain/chain_member.rs
@@ -14,35 +14,33 @@ use std::fmt::Debug;
 #[derive(Clone, Debug)]
 pub(crate) enum ChainMember {
     /// Holds onto a [rome_js_syntax::JsStaticMemberExpression]
-    StaticMember(JsStaticMemberExpression),
+    StaticMember {
+        expression: JsStaticMemberExpression,
+        root: bool,
+    },
+
     /// Holds onto a [rome_js_syntax::JsCallExpression]
-    CallExpression(JsCallExpression),
+    CallExpression {
+        expression: JsCallExpression,
+        root: bool,
+    },
+
     /// Holds onto a [rome_js_syntax::JsComputedMemberExpression]
-    ComputedMember(JsComputedMemberExpression),
+    ComputedMember {
+        expression: JsComputedMemberExpression,
+        root: bool,
+    },
+
     /// Any other node that are not  [rome_js_syntax::JsCallExpression] or [rome_js_syntax::JsStaticMemberExpression]
     /// Are tracked using this variant
     Node(JsSyntaxNode),
 }
 
 impl ChainMember {
-    pub(crate) fn has_trailing_comments(&self) -> bool {
-        self.syntax().has_trailing_comments()
-    }
-
-    /// Returns true if the member any of it's ancestor parentheses nodes has any leading comments.
-    pub(crate) fn has_leading_comments(&self) -> SyntaxResult<bool> {
-        let has_operator_comment = match self {
-            ChainMember::StaticMember(node) => node.operator_token()?.has_leading_comments(),
-            _ => false,
-        };
-
-        Ok(self.syntax().has_leading_comments() || has_operator_comment)
-    }
-
     /// checks if the current node is a [rome_js_syntax::JsCallExpression],  [rome_js_syntax::JsImportExpression] or a [rome_js_syntax::JsNewExpression]
     pub fn is_loose_call_expression(&self) -> bool {
         match self {
-            ChainMember::CallExpression(_) => true,
+            ChainMember::CallExpression { .. } => true,
             ChainMember::Node(node) => {
                 JsImportCallExpression::can_cast(node.kind())
                     | JsNewExpression::can_cast(node.kind())
@@ -53,15 +51,15 @@ impl ChainMember {
 
     pub(crate) fn syntax(&self) -> &JsSyntaxNode {
         match self {
-            ChainMember::StaticMember(node) => node.syntax(),
-            ChainMember::CallExpression(node) => node.syntax(),
-            ChainMember::ComputedMember(node) => node.syntax(),
+            ChainMember::StaticMember { expression, .. } => expression.syntax(),
+            ChainMember::CallExpression { expression, .. } => expression.syntax(),
+            ChainMember::ComputedMember { expression, .. } => expression.syntax(),
             ChainMember::Node(node) => node,
         }
     }
 
     pub const fn is_computed_expression(&self) -> bool {
-        matches!(self, ChainMember::ComputedMember(..))
+        matches!(self, ChainMember::ComputedMember { .. })
     }
 
     pub(crate) fn is_this_expression(&self) -> bool {
@@ -102,10 +100,10 @@ impl ChainMember {
                 || text.starts_with('$')
         }
 
-        if let ChainMember::StaticMember(static_member, ..) = self {
+        if let ChainMember::StaticMember { expression, .. } = self {
             if check_left_hand_side {
                 if let JsAnyExpression::JsIdentifierExpression(identifier_expression) =
-                    static_member.object()?
+                    expression.object()?
                 {
                     let value_token = identifier_expression.name()?.value_token()?;
                     let text = value_token.text_trimmed();
@@ -114,7 +112,7 @@ impl ChainMember {
                     Ok(false)
                 }
             } else {
-                Ok(check_str(static_member.member()?.text().as_str()))
+                Ok(check_str(expression.member()?.text().as_str()))
             }
         } else if let ChainMember::Node(node, ..) = self {
             if let Some(identifier_expression) = JsIdentifierExpression::cast(node.clone()) {
@@ -130,9 +128,9 @@ impl ChainMember {
     }
 
     pub(crate) fn has_short_name(&self, tab_width: TabWidth) -> SyntaxResult<bool> {
-        if let ChainMember::StaticMember(static_member, ..) = self {
+        if let ChainMember::StaticMember { expression, .. } = self {
             if let JsAnyExpression::JsIdentifierExpression(identifier_expression) =
-                static_member.object()?
+                expression.object()?
             {
                 let value_token = identifier_expression.name()?.value_token()?;
                 let text = value_token.text_trimmed();
@@ -149,34 +147,45 @@ impl ChainMember {
 impl Format<JsFormatContext> for ChainMember {
     fn fmt(&self, f: &mut JsFormatter) -> FormatResult<()> {
         match self {
-            ChainMember::StaticMember(static_member) => {
+            ChainMember::StaticMember { expression, root } => {
                 let JsStaticMemberExpressionFields {
                     // Formatted as part of the previous item
                     object: _,
                     operator_token,
                     member,
-                } = static_member.as_fields();
-                write![f, [operator_token.format(), member.format()]]
+                } = expression.as_fields();
+                write![
+                    f,
+                    [
+                        (!root).then_some(format_leading_comments(expression.syntax())),
+                        operator_token.format(),
+                        member.format(),
+                        (!root).then_some(format_trailing_comments(expression.syntax()))
+                    ]
+                ]
             }
-            ChainMember::CallExpression(call_expression) => {
+
+            ChainMember::CallExpression { expression, root } => {
                 let JsCallExpressionFields {
                     // Formatted as part of the previous item
                     callee: _,
                     optional_chain_token,
                     type_arguments,
                     arguments,
-                } = call_expression.as_fields();
+                } = expression.as_fields();
 
                 write!(
                     f,
                     [
+                        (!root).then_some(format_leading_comments(expression.syntax())),
                         optional_chain_token.format(),
                         type_arguments.format(),
-                        arguments.format()
+                        arguments.format(),
+                        (!root).then_some(format_trailing_comments(expression.syntax()))
                     ]
                 )
             }
-            ChainMember::ComputedMember(computed_member) => {
+            ChainMember::ComputedMember { expression, root } => {
                 let JsComputedMemberExpressionFields {
                     // Formatted as part of the previous item
                     object: _,
@@ -184,14 +193,16 @@ impl Format<JsFormatContext> for ChainMember {
                     l_brack_token,
                     member,
                     r_brack_token,
-                } = computed_member.as_fields();
+                } = expression.as_fields();
                 write!(
                     f,
                     [
+                        (!root).then_some(format_leading_comments(expression.syntax())),
                         optional_chain_token.format(),
                         l_brack_token.format(),
                         member.format(),
                         r_brack_token.format(),
+                        (!root).then_some(format_trailing_comments(expression.syntax()))
                     ]
                 )
             }
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 949fc2b1411..7dcf3479008 100644
--- a/crates/rome_js_formatter/src/utils/member_chain/groups.rs
+++ b/crates/rome_js_formatter/src/utils/member_chain/groups.rs
@@ -93,43 +93,40 @@ pub(super) struct MemberChainGroups {
 }
 
 impl MemberChainGroups {
+    pub(crate) fn is_empty(&self) -> bool {
+        self.groups.is_empty()
+    }
+
     /// This function checks if the current grouping should be merged with the first group.
-    pub fn should_merge(&self, head_group: &MemberChainGroup) -> SyntaxResult<bool> {
+    pub fn should_merge(
+        &self,
+        head_group: &MemberChainGroup,
+        comments: &JsComments,
+    ) -> SyntaxResult<bool> {
         Ok(!self.groups.len() >= 1
             && self.should_not_wrap(head_group)?
             && !self.groups[0]
                 .members
                 .first()
-                .map_or(false, |item| item.has_trailing_comments()))
+                .map_or(false, |item| comments.has_comments(item.syntax())))
     }
 
     /// Checks if the groups contain comments.
-    pub fn has_comments(&self) -> SyntaxResult<bool> {
-        let mut has_leading_comments = false;
-
-        let flat_groups = self.groups.iter().flat_map(|item| item.members.iter());
-        for item in flat_groups {
-            if item.has_leading_comments()? {
-                has_leading_comments = true;
-                break;
-            }
-        }
+    pub fn has_comments(&self, comments: &JsComments) -> bool {
+        let mut members = self.groups.iter().flat_map(|item| item.members.iter());
 
-        let has_trailing_comments = self
-            .groups
-            .iter()
-            .flat_map(|item| item.members.iter())
-            .any(|item| item.has_trailing_comments());
+        let has_comments = members.any(|item| {
+            comments.has_trailing_comments(item.syntax())
+                || comments.has_leading_comments(item.syntax())
+        });
 
         let cutoff_has_leading_comments = if self.groups.len() >= self.cutoff as usize {
             let group = self.groups.get(self.cutoff as usize);
             if let Some(group) = group {
                 let first_item = group.members.first();
-                if let Some(first_item) = first_item {
-                    first_item.has_leading_comments()?
-                } else {
-                    false
-                }
+                first_item.map_or(false, |first_item| {
+                    comments.has_leading_comments(first_item.syntax())
+                })
             } else {
                 false
             }
@@ -137,7 +134,7 @@ impl MemberChainGroups {
             false
         };
 
-        Ok(has_leading_comments || has_trailing_comments || cutoff_has_leading_comments)
+        has_comments || cutoff_has_leading_comments
     }
 
     /// Filters the stack of [FlattenItem] and return only the ones that
@@ -147,8 +144,8 @@ impl MemberChainGroups {
             .iter()
             .flat_map(|group| group.members.iter())
             .filter_map(|item| {
-                if let ChainMember::CallExpression(call_expression, ..) = item {
-                    Some(call_expression)
+                if let ChainMember::CallExpression { expression, .. } = item {
+                    Some(expression)
                 } else {
                     None
                 }
@@ -198,8 +195,9 @@ impl MemberChainGroups {
     pub(crate) fn should_merge_with_first_group(
         &mut self,
         head_group: &MemberChainGroup,
+        comments: &JsComments,
     ) -> Option<Vec<MemberChainGroup>> {
-        if self.should_merge(head_group).unwrap_or(false) {
+        if self.should_merge(head_group, comments).unwrap_or(false) {
             let mut new_groups = self.groups.split_off(1);
             // self.groups is now the head (one element), while `new_groups` is a new vector without the
             // first element.
@@ -214,8 +212,8 @@ impl MemberChainGroups {
     /// Here we check if the length of the groups exceeds the cutoff or there are comments
     /// This function is the inverse of the prettier function
     /// [Prettier applies]: https://github.com/prettier/prettier/blob/a043ac0d733c4d53f980aa73807a63fc914f23bd/src/language-js/print/member-chain.js#L342
-    pub(crate) fn is_member_call_chain(&self) -> SyntaxResult<bool> {
-        Ok(self.groups.len() > self.cutoff as usize || self.has_comments()?)
+    pub(crate) fn is_member_call_chain(&self, comments: &JsComments) -> bool {
+        self.groups.len() > self.cutoff as usize || self.has_comments(comments)
     }
 
     pub(super) fn iter(&self) -> impl Iterator<Item = &MemberChainGroup> {
@@ -247,8 +245,17 @@ impl MemberChainGroup {
         self.members.extend(group)
     }
 
-    pub(super) fn has_comments(&self) -> bool {
-        self.members.iter().any(|item| item.has_trailing_comments())
+    pub(super) fn has_comments(&self, comments: &JsComments) -> bool {
+        self.members.iter().enumerate().any(|(index, member)| {
+            if index == 0 {
+                comments.has_trailing_comments(member.syntax())
+            } else if index < self.members.len() {
+                comments.has_leading_comments(member.syntax())
+                    || comments.has_trailing_comments(member.syntax())
+            } else {
+                false
+            }
+        })
     }
 }
 
@@ -263,8 +270,8 @@ impl Format<JsFormatContext> for MemberChainGroup {
         let last = self.members.last();
 
         let needs_parens = last.map_or(false, |last| match last {
-            ChainMember::StaticMember(member) => member.needs_parentheses(),
-            ChainMember::ComputedMember(member) => member.needs_parentheses(),
+            ChainMember::StaticMember { expression, .. } => expression.needs_parentheses(),
+            ChainMember::ComputedMember { expression, .. } => expression.needs_parentheses(),
             _ => false,
         });
 
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 e227afb660e..0d5c0019603 100644
--- a/crates/rome_js_formatter/src/utils/member_chain/mod.rs
+++ b/crates/rome_js_formatter/src/utils/member_chain/mod.rs
@@ -112,8 +112,8 @@ use crate::utils::member_chain::groups::{
     MemberChainGroup, MemberChainGroups, MemberChainGroupsBuilder,
 };
 use crate::utils::member_chain::simple_argument::SimpleArgument;
-use rome_formatter::{format_args, write, Buffer, Comments, CstFormatContext};
-use rome_js_syntax::{JsAnyExpression, JsCallExpression, JsExpressionStatement, JsLanguage};
+use rome_formatter::{format_args, write, Buffer, CstFormatContext};
+use rome_js_syntax::{JsAnyExpression, JsCallExpression, JsExpressionStatement};
 use rome_rowan::{AstNode, SyntaxResult};
 
 #[derive(Debug, Clone)]
@@ -125,7 +125,18 @@ pub(crate) struct MemberChain {
 
 impl MemberChain {
     /// It tells if the groups should be break on multiple lines
-    pub(crate) fn groups_should_break(&self) -> FormatResult<bool> {
+    pub(crate) fn groups_should_break(&self, comments: &JsComments) -> FormatResult<bool> {
+        if self.tail.is_empty() {
+            return Ok(false);
+        }
+
+        let node_has_comments =
+            self.head.has_comments(comments) || self.tail.has_comments(comments);
+
+        if node_has_comments {
+            return Ok(true);
+        }
+
         // Do not allow the group to break if it only contains a single call expression
         if self.calls_count <= 1 {
             return Ok(false);
@@ -139,11 +150,7 @@ impl MemberChain {
 
         // TODO: add here will_break logic
 
-        let node_has_comments = self.tail.has_comments()? || self.head.has_comments();
-
-        let should_break = node_has_comments || call_expressions_are_not_simple;
-
-        Ok(should_break)
+        Ok(call_expressions_are_not_simple)
     }
 
     /// We retrieve all the call expressions inside the group and we check if
@@ -166,7 +173,7 @@ impl Format<JsFormatContext> for MemberChain {
         // TODO use Alternatives once available
         write!(f, [&self.head])?;
 
-        if self.groups_should_break()? {
+        if self.groups_should_break(f.context().comments())? {
             write!(
                 f,
                 [indent(&format_args!(
@@ -198,6 +205,7 @@ pub(crate) fn get_member_chain(
         &mut chain_members,
         call_expression.clone().into(),
         f.context().comments(),
+        true,
     )?;
 
     chain_members.push(root);
@@ -228,7 +236,9 @@ pub(crate) fn get_member_chain(
 
     // Here we check if the first element of Groups::groups can be moved inside the head.
     // If so, then we extract it and concatenate it together with the head.
-    if let Some(group_to_merge) = rest_of_groups.should_merge_with_first_group(&head_group) {
+    if let Some(group_to_merge) =
+        rest_of_groups.should_merge_with_first_group(&head_group, f.comments())
+    {
         let group_to_merge = group_to_merge
             .into_iter()
             .flat_map(|group| group.into_members());
@@ -260,7 +270,7 @@ fn compute_first_group_index(flatten_items: &[ChainMember]) -> usize {
                 // - `something[1][2][4]`
                 // - `something[1]()[3]()`
                 // - `something()[2].something.else[0]`
-                ChainMember::CallExpression(_) | ChainMember::ComputedMember(_) => true,
+                ChainMember::CallExpression { .. } | ChainMember::ComputedMember { .. } => true,
 
                 // SAFETY: The check `flatten_items[index + 1]` will never panic at runtime because
                 // 1. The array will always have at least two items
@@ -291,11 +301,11 @@ fn compute_first_group_index(flatten_items: &[ChainMember]) -> usize {
                 // and the next one is a call expression... the `matches!` fails and the loop is stopped.
                 //
                 // The last element of the array is always a `CallExpression`, which allows us to avoid the overflow of the array.
-                ChainMember::StaticMember(_) => {
+                ChainMember::StaticMember { .. } => {
                     let next_flatten_item = &flatten_items[index + 1];
                     matches!(
                         next_flatten_item,
-                        ChainMember::StaticMember(_) | ChainMember::ComputedMember(_)
+                        ChainMember::StaticMember { .. } | ChainMember::ComputedMember { .. }
                     )
                 }
                 _ => false,
@@ -323,10 +333,10 @@ fn compute_groups(
     let mut groups_builder =
         MemberChainGroupsBuilder::new(in_expression_statement, f.options().tab_width());
     for item in flatten_items {
-        let has_trailing_comments = item.syntax().has_trailing_comments();
+        let has_trailing_comments = f.comments().has_trailing_comments(item.syntax());
 
         match item {
-            ChainMember::StaticMember(_) => {
+            ChainMember::StaticMember { .. } => {
                 // if we have seen a JsCallExpression, we want to close the group.
                 // The resultant group will be something like: [ . , then, () ];
                 // `.` and `then` belong to the previous StaticMemberExpression,
@@ -340,14 +350,14 @@ fn compute_groups(
                     groups_builder.start_or_continue_group(item);
                 }
             }
-            ChainMember::CallExpression(_) => {
+            ChainMember::CallExpression { .. } => {
                 let is_loose_call_expression = item.is_loose_call_expression();
                 groups_builder.start_or_continue_group(item);
                 if is_loose_call_expression {
                     has_seen_call_expression = true;
                 }
             }
-            ChainMember::ComputedMember(_) => {
+            ChainMember::ComputedMember { .. } => {
                 groups_builder.start_or_continue_group(item);
             }
             ChainMember::Node(_) => groups_builder.continue_group(item),
@@ -372,7 +382,8 @@ fn compute_groups(
 fn flatten_member_chain(
     queue: &mut Vec<ChainMember>,
     node: JsAnyExpression,
-    comments: &Comments<JsLanguage>,
+    comments: &JsComments,
+    root: bool,
 ) -> SyntaxResult<ChainMember> {
     use JsAnyExpression::*;
 
@@ -380,32 +391,44 @@ fn flatten_member_chain(
         return Ok(ChainMember::Node(node.into_syntax()));
     }
 
-    match node {
+    let member = match node {
         JsCallExpression(call_expression) => {
             let callee = call_expression.callee()?;
-            let left = flatten_member_chain(queue, callee, comments)?;
+            let left = flatten_member_chain(queue, callee, comments, false)?;
             queue.push(left);
 
-            Ok(ChainMember::CallExpression(call_expression))
+            ChainMember::CallExpression {
+                expression: call_expression,
+                root,
+            }
         }
+
         JsStaticMemberExpression(static_member) => {
             let object = static_member.object()?;
-            let left = flatten_member_chain(queue, object, comments)?;
+            let left = flatten_member_chain(queue, object, comments, false)?;
             queue.push(left);
 
-            Ok(ChainMember::StaticMember(static_member))
+            ChainMember::StaticMember {
+                expression: static_member,
+                root,
+            }
         }
 
         JsComputedMemberExpression(computed_expression) => {
             let object = computed_expression.object()?;
 
-            let left = flatten_member_chain(queue, object, comments)?;
+            let left = flatten_member_chain(queue, object, comments, false)?;
             queue.push(left);
 
-            Ok(ChainMember::ComputedMember(computed_expression))
+            ChainMember::ComputedMember {
+                expression: computed_expression,
+                root,
+            }
         }
-        expression => Ok(ChainMember::Node(expression.into_syntax())),
-    }
+        expression => ChainMember::Node(expression.into_syntax()),
+    };
+
+    Ok(member)
 }
 
 /// Here we check if the length of the groups exceeds the cutoff or there are comments
@@ -417,5 +440,5 @@ pub fn is_member_call_chain(
 ) -> SyntaxResult<bool> {
     let chain = get_member_chain(expression, f)?;
 
-    chain.tail.is_member_call_chain()
+    Ok(chain.tail.is_member_call_chain(f.context().comments()))
 }
diff --git a/crates/rome_js_formatter/src/utils/mod.rs b/crates/rome_js_formatter/src/utils/mod.rs
index 4403ea25e7e..95f4e1048a8 100644
--- a/crates/rome_js_formatter/src/utils/mod.rs
+++ b/crates/rome_js_formatter/src/utils/mod.rs
@@ -16,7 +16,6 @@ mod typescript;
 
 pub(crate) use crate::parentheses::resolve_left_most_expression;
 use crate::prelude::*;
-use crate::JsCommentStyle;
 pub(crate) use assignment_like::{
     with_assignment_layout, AssignmentLikeLayout, JsAnyAssignmentLike,
 };
@@ -27,9 +26,9 @@ pub(crate) use conditional::{ConditionalJsxChain, JsAnyConditional};
 pub(crate) use member_chain::get_member_chain;
 pub(crate) use object_like::JsObjectLike;
 pub(crate) use object_pattern_like::JsObjectPatternLike;
-use rome_formatter::{format_args, write, Buffer, CommentStyle};
+use rome_formatter::{format_args, write, Buffer};
 use rome_js_syntax::{JsAnyExpression, JsAnyStatement, JsInitializerClause, JsLanguage, Modifiers};
-use rome_js_syntax::{JsSyntaxKind, JsSyntaxNode, JsSyntaxToken};
+use rome_js_syntax::{JsSyntaxNode, JsSyntaxToken};
 use rome_rowan::{AstNode, AstNodeList};
 pub(crate) use string_utils::*;
 pub(crate) use typescript::{
@@ -208,7 +207,7 @@ impl Format<JsFormatContext> for FormatWithSemicolon<'_> {
         if let Some(semicolon) = self.semicolon {
             write!(f, [semicolon.format()])?;
         } else if !is_unknown {
-            format_inserted(JsSyntaxKind::SEMICOLON).fmt(f)?;
+            text(";").fmt(f)?;
         }
         Ok(())
     }
@@ -251,45 +250,3 @@ where
 
     join_with.finish()
 }
-
-pub(crate) fn has_trailing_line_comment(node: &JsSyntaxNode) -> bool {
-    node.last_token()
-        .map_or(false, |token| has_token_trailing_line_comment(&token))
-}
-
-pub(crate) fn has_token_trailing_line_comment(token: &JsSyntaxToken) -> bool {
-    token
-        .trailing_trivia()
-        .pieces()
-        .filter_map(|piece| piece.as_comments())
-        .any(|comment| JsCommentStyle.get_comment_kind(&comment).is_line())
-}
-
-/// Tests if the node has any leading comment that will be placed on its own line.
-pub(crate) fn has_leading_own_line_comment(node: &JsSyntaxNode) -> bool {
-    if let Some(leading_trivia) = node.first_leading_trivia() {
-        let mut first_comment = true;
-        let mut after_comment = false;
-        let mut after_new_line = false;
-
-        for piece in leading_trivia.pieces() {
-            if piece.is_comments() {
-                if after_new_line && first_comment {
-                    return true;
-                } else {
-                    first_comment = false;
-                    after_comment = true;
-                }
-            } else if piece.is_newline() {
-                if after_comment {
-                    return true;
-                } else {
-                    after_new_line = true;
-                }
-            } else if piece.is_skipped() {
-                return false;
-            }
-        }
-    }
-    false
-}
diff --git a/crates/rome_js_formatter/src/utils/object.rs b/crates/rome_js_formatter/src/utils/object.rs
index 3394eba8785..a9e7dac7595 100644
--- a/crates/rome_js_formatter/src/utils/object.rs
+++ b/crates/rome_js_formatter/src/utils/object.rs
@@ -41,7 +41,14 @@ pub(crate) fn write_member_name(
                 let format = FormatLiteralStringToken::new(&value, StringLiteralParentKind::Member);
                 let cleaned = format.clean_text(f.options());
 
-                write!(f, [cleaned])?;
+                write!(
+                    f,
+                    [
+                        format_leading_comments(name.syntax()),
+                        cleaned,
+                        format_trailing_comments(name.syntax())
+                    ]
+                )?;
 
                 Ok(cleaned.width())
             } else {
diff --git a/crates/rome_js_formatter/src/utils/object_like.rs b/crates/rome_js_formatter/src/utils/object_like.rs
index dd1a4ba0c9f..44f2964c664 100644
--- a/crates/rome_js_formatter/src/utils/object_like.rs
+++ b/crates/rome_js_formatter/src/utils/object_like.rs
@@ -52,30 +52,20 @@ impl JsObjectLike {
 impl Format<JsFormatContext> for JsObjectLike {
     fn fmt(&self, f: &mut JsFormatter) -> FormatResult<()> {
         let members = format_with(|f| self.write_members(f));
+
+        write!(f, [self.l_curly_token().format(),])?;
+
         if self.members_are_empty() {
             write!(
                 f,
-                [
-                    format_delimited(&self.l_curly_token()?, &members, &self.r_curly_token()?)
-                        .soft_block_indent()
-                ]
-            )
+                [format_dangling_comments(self.syntax()).with_block_indent(),]
+            )?;
         } else if self.members_have_leading_newline() {
-            write!(
-                f,
-                [
-                    format_delimited(&self.l_curly_token()?, &members, &self.r_curly_token()?)
-                        .block_indent()
-                ]
-            )
+            write!(f, [block_indent(&members)])?;
         } else {
-            write!(
-                f,
-                [
-                    format_delimited(&self.l_curly_token()?, &members, &self.r_curly_token()?)
-                        .soft_block_spaces()
-                ]
-            )
+            write!(f, [group(&soft_space_or_block_indent(&members))])?;
         }
+
+        write!(f, [self.r_curly_token().format()])
     }
 }
diff --git a/crates/rome_js_formatter/src/utils/object_pattern_like.rs b/crates/rome_js_formatter/src/utils/object_pattern_like.rs
index 7a7e8d1ea42..037c25adf43 100644
--- a/crates/rome_js_formatter/src/utils/object_pattern_like.rs
+++ b/crates/rome_js_formatter/src/utils/object_pattern_like.rs
@@ -125,18 +125,17 @@ impl Format<JsFormatContext> for JsObjectPatternLike {
         let is_in_assignment_like = self.is_in_assignment_like();
         let properties_len = self.properties_len();
 
-        if should_break_properties {
+        write!(f, [self.l_curly_token().format()])?;
+
+        if properties_len == 0 {
             write!(
                 f,
-                [
-                    &self.l_curly_token()?.format(),
-                    &block_indent(right),
-                    &self.r_curly_token()?.format(),
-                ]
-            )
+                [format_dangling_comments(self.syntax()).with_soft_block_indent()]
+            )?;
+        } else if should_break_properties {
+            write!(f, [block_indent(right)])?;
         } else if !should_break_properties && is_in_assignment_like {
             // no need to add a group if we know the parent already does that
-            write!(f, [&self.l_curly_token()?.format()])?;
             if properties_len > 0 {
                 write!(f, [soft_line_break_or_space()])?;
                 write!(f, [soft_block_indent(right)])?;
@@ -144,15 +143,10 @@ impl Format<JsFormatContext> for JsObjectPatternLike {
             } else {
                 write!(f, [right])?;
             }
-            write!(f, [&self.r_curly_token()?.format()])
         } else {
-            write!(
-                f,
-                [
-                    format_delimited(&self.l_curly_token()?, right, &self.r_curly_token()?,)
-                        .soft_block_spaces()
-                ]
-            )
+            write!(f, [group(&soft_space_or_block_indent(&right))])?;
         }
+
+        write!(f, [self.r_curly_token().format()])
     }
 }
diff --git a/crates/rome_js_formatter/tests/specs/js/module/arrow/call.js.snap b/crates/rome_js_formatter/tests/specs/js/module/arrow/call.js.snap
index 3290e5c1e57..c3ffef92cb1 100644
--- a/crates/rome_js_formatter/tests/specs/js/module/arrow/call.js.snap
+++ b/crates/rome_js_formatter/tests/specs/js/module/arrow/call.js.snap
@@ -63,7 +63,7 @@ const testResults = results.testResults.map(
 
 it("mocks regexp instances", () => {
 	expect(
-	// () => moduleMocker.generateFromMetadata(moduleMocker.getMetadata(/a/)),
+		// () => moduleMocker.generateFromMetadata(moduleMocker.getMetadata(/a/)),
 	).not.toThrow();
 });
 
@@ -79,8 +79,9 @@ expect(
 );
 // .toThrowError(/Required parameter/);
 
-expect(() => asyncRequest({ type: "foo", url: "/test-endpoint" })).not
-	.toThrowError();
+expect(
+	() => asyncRequest({ type: "foo", url: "/test-endpoint" }),
+).not.toThrowError();
 
 expect(
 	() =>
diff --git a/crates/rome_js_formatter/tests/specs/js/module/assignment/assignment.js b/crates/rome_js_formatter/tests/specs/js/module/assignment/assignment.js
index e657c49f244..149e3c5e277 100644
--- a/crates/rome_js_formatter/tests/specs/js/module/assignment/assignment.js
+++ b/crates/rome_js_formatter/tests/specs/js/module/assignment/assignment.js
@@ -149,6 +149,6 @@ a =
 a =
     {
 // rome-ignore format: test
-        a: { t: c = b }, loreum, ipsurm
+        a: { t: c = b       }, loreum, ipsurm
     } = {}
 
diff --git a/crates/rome_js_formatter/tests/specs/js/module/assignment/assignment.js.snap b/crates/rome_js_formatter/tests/specs/js/module/assignment/assignment.js.snap
index 1059370ade4..57f7ac9029e 100644
--- a/crates/rome_js_formatter/tests/specs/js/module/assignment/assignment.js.snap
+++ b/crates/rome_js_formatter/tests/specs/js/module/assignment/assignment.js.snap
@@ -154,7 +154,7 @@ a =
 a =
     {
 // rome-ignore format: test
-        a: { t: c = b }, loreum, ipsurm
+        a: { t: c = b       }, loreum, ipsurm
     } = {}
 
 
@@ -381,13 +381,13 @@ a = {
 
 a =
 	// rome-ignore format: test
-{
+	{
     a: { t: c = b }, loreum, ipsurm
 } = {};
 
 a = {
 	// rome-ignore format: test
-        a: { t: c = b },
+	a: { t: c = b       },
 	loreum,
 	ipsurm,
 } = {};
diff --git a/crates/rome_js_formatter/tests/specs/js/module/binding/array-binding-holes.js.snap b/crates/rome_js_formatter/tests/specs/js/module/binding/array-binding-holes.js.snap
index b35a8e6d331..0084e44b745 100644
--- a/crates/rome_js_formatter/tests/specs/js/module/binding/array-binding-holes.js.snap
+++ b/crates/rome_js_formatter/tests/specs/js/module/binding/array-binding-holes.js.snap
@@ -14,5 +14,5 @@ Line width: 80
 Quote style: Double Quotes
 Quote properties: As needed
 -----
-function foo([foo, /* not used */ , /* not used */]) {}
+function foo([foo, /* not used */ /* not used */ ,]) {}
 
diff --git a/crates/rome_js_formatter/tests/specs/js/module/call_expression.js.snap b/crates/rome_js_formatter/tests/specs/js/module/call_expression.js.snap
index b81191b2bc7..d7769be0a00 100644
--- a/crates/rome_js_formatter/tests/specs/js/module/call_expression.js.snap
+++ b/crates/rome_js_formatter/tests/specs/js/module/call_expression.js.snap
@@ -69,7 +69,10 @@ useMemo(() => {
 	};
 }, [a, b]);
 
-useMemo(() => {}, [a, b]); // some comment
+useMemo(
+	() => {}, // some comment
+	[a, b],
+);
 
 useEffect(() => {
 	if (clipboardStatus !== "normal") {
@@ -99,9 +102,11 @@ test.expect((t) => {
 	t.true(a);
 }, false);
 
-test.expect((t) => {
-	t.true(a);
-}, false
-// comment
+test.expect(
+	(t) => {
+		t.true(a);
+	},
+	false,
+	// comment
 );
 
diff --git a/crates/rome_js_formatter/tests/specs/js/module/class/class_comments.js.snap b/crates/rome_js_formatter/tests/specs/js/module/class/class_comments.js.snap
index d80114811e0..73ac6426c2d 100644
--- a/crates/rome_js_formatter/tests/specs/js/module/class/class_comments.js.snap
+++ b/crates/rome_js_formatter/tests/specs/js/module/class/class_comments.js.snap
@@ -24,6 +24,7 @@ class A extends B {
 	constructor() {
 		super();
 	}
+
 	// trailing comment
 }
 
diff --git a/crates/rome_js_formatter/tests/specs/js/module/comments.js.snap b/crates/rome_js_formatter/tests/specs/js/module/comments.js.snap
index 3a280bed2b0..4a6d4e06390 100644
--- a/crates/rome_js_formatter/tests/specs/js/module/comments.js.snap
+++ b/crates/rome_js_formatter/tests/specs/js/module/comments.js.snap
@@ -97,14 +97,14 @@ import {
 
 expression(/* block comment */);
 
+expression(/* block comment */);
+
 expression(
-/* block comment */
+	// line comment
 );
 
-expression(); // line comment
-
 expression(
-// line comment
+	// line comment
 );
 
 expression(
@@ -120,9 +120,11 @@ expression(
 	"something",
 );
 
-const array0 = [/*0*/];
-const array1 = [/*0*/, /*1*/];
-const array2 = [/*0*/, /*1*/ , /*2*/];
+const array0 = [
+	/*0*/
+];
+const array1 = [/*0*/ /*1*/ ,];
+const array2 = [/*0*/ , /*1*/ /*2*/ ,];
 
 /* block comment */
 statement();
@@ -156,12 +158,14 @@ function name(
 
 4 + /* plus trailing */ 3 * 2 /* 2 trailing */;
 
-/* leading of opening */ /* trailing of opening */ 4 +
-	3 /* leading of closing */ /* trailing of closing */;
+/* leading of opening */ /* trailing of opening */ 4 + 3;
+
+/* leading of closing */
+/* trailing of closing */
 
 [3 /* trailing num */ /* trailing sep */];
 
-function test /* spacing before parentheses*/ () {}
+function test /* spacing before parentheses*/() {}
 
 a /* before member */.test;
 statement /* comment */;
@@ -170,5 +174,6 @@ statement /* comment */;
 
 /* leading */
 ("test") /*trailing*/;
+
 /* EOF comment */
 
diff --git a/crates/rome_js_formatter/tests/specs/js/module/declarations/variable_declaration.js.snap b/crates/rome_js_formatter/tests/specs/js/module/declarations/variable_declaration.js.snap
index 3976df0f3c0..f7e95fbf442 100644
--- a/crates/rome_js_formatter/tests/specs/js/module/declarations/variable_declaration.js.snap
+++ b/crates/rome_js_formatter/tests/specs/js/module/declarations/variable_declaration.js.snap
@@ -290,16 +290,15 @@ Quote properties: As needed
 	} = privateNamesMap.get(name);
 
 	// rome-ignore format: test
-		const {
+	const {
 			id, static: isStatic, method: isMethod,
 			methodId, getId, setId,
 		} = privateNamesMap.get(name);
 
 	const { id1, method: isMethod1, methodId1 } = privateNamesMap.get(name);
 
-	const { id1, method: isMethod1, methodId1 } =
-	// rome-ignore format: test
-			privateNamesMap.get(name);
+	const { id1, method: isMethod1, methodId1 } = // rome-ignore format: test
+	privateNamesMap.get(name);
 
 	const {
 		id3,
@@ -308,7 +307,7 @@ Quote properties: As needed
 	} = anodyneCondosMalateOverateRetinol.get(bifornCringerMoshedPerplexSawder);
 
 	// rome-ignore format: test
-		const {
+	const {
 			id3, method: isMethod3,
 			methodId3,
 		} =
@@ -738,68 +737,68 @@ let looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo
 
 const a
 	// rome-ignore format: Ignore the initializer
-				=
+	=
 
 			[A,    B,   C].push( aaa );
 
 
 ## Lines exceeding width of 80 characters
 
-   74: var loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong1 =
-   76: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong2 =
-   78: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong3 =
-   80: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong4 =
-   82: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong5 =
-  194: var looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong1 =
-  196: let looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong2 =
-  198: let looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong3 =
-  200: let looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong4 =
-  204: var loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong1 =
-  206: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong2 =
-  208: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong3 =
-  210: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong4 =
-  214: var loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong1 =
-  216: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong2 =
-  220: var loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong1 =
-  222: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong2 =
-  224: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong3 =
-  226: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong4 =
-  230: var loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong1 =
-  232: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong2 =
-  234: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong3 =
-  236: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong4 =
-  240: var loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong1 =
-  242: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong2 =
-  244: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong3 =
-  246: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong4 =
-  250: var loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong1 =
-  252: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong2 =
-  254: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong3 =
-  256: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong4 =
-  368: var loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong1 =
-  370: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong2 =
-  372: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong3 =
-  376: var loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong1 =
-  378: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong2 =
-  380: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong3 =
-  382: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong4 =
-  386: var loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong1 =
-  388: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong2 =
-  390: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong3 =
-  392: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong4 =
-  396: var loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong1 =
-  398: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong2 =
-  400: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong3 =
-  403: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong4 =
-  408: var loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong1 =
-  410: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong2 =
-  412: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong3 =
-  417: var loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong1 =
-  419: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong2 =
-  421: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong3 =
-  425: var loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong1 =
-  430: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong2 =
-  435: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong3 =
-  451: var loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong1 =
-  453: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong2 =
+   73: var loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong1 =
+   75: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong2 =
+   77: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong3 =
+   79: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong4 =
+   81: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong5 =
+  193: var looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong1 =
+  195: let looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong2 =
+  197: let looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong3 =
+  199: let looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong4 =
+  203: var loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong1 =
+  205: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong2 =
+  207: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong3 =
+  209: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong4 =
+  213: var loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong1 =
+  215: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong2 =
+  219: var loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong1 =
+  221: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong2 =
+  223: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong3 =
+  225: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong4 =
+  229: var loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong1 =
+  231: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong2 =
+  233: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong3 =
+  235: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong4 =
+  239: var loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong1 =
+  241: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong2 =
+  243: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong3 =
+  245: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong4 =
+  249: var loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong1 =
+  251: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong2 =
+  253: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong3 =
+  255: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong4 =
+  367: var loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong1 =
+  369: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong2 =
+  371: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong3 =
+  375: var loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong1 =
+  377: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong2 =
+  379: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong3 =
+  381: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong4 =
+  385: var loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong1 =
+  387: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong2 =
+  389: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong3 =
+  391: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong4 =
+  395: var loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong1 =
+  397: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong2 =
+  399: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong3 =
+  402: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong4 =
+  407: var loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong1 =
+  409: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong2 =
+  411: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong3 =
+  416: var loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong1 =
+  418: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong2 =
+  420: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong3 =
+  424: var loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong1 =
+  429: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong2 =
+  434: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong3 =
+  450: var loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong1 =
+  452: let loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong2 =
 
diff --git a/crates/rome_js_formatter/tests/specs/js/module/expression/binary_expression.js.snap b/crates/rome_js_formatter/tests/specs/js/module/expression/binary_expression.js.snap
index 50b3daaf597..6523e58df68 100644
--- a/crates/rome_js_formatter/tests/specs/js/module/expression/binary_expression.js.snap
+++ b/crates/rome_js_formatter/tests/specs/js/module/expression/binary_expression.js.snap
@@ -80,5 +80,5 @@ a +
 	b +
 	4 +
 	// rome-ignore format: Test formatting ignored binary expressions
-  -   4_444_444;
+	-   4_444_444;
 
diff --git a/crates/rome_js_formatter/tests/specs/js/module/expression/logical_expression.js.snap b/crates/rome_js_formatter/tests/specs/js/module/expression/logical_expression.js.snap
index 0975e69a094..268598dc1ac 100644
--- a/crates/rome_js_formatter/tests/specs/js/module/expression/logical_expression.js.snap
+++ b/crates/rome_js_formatter/tests/specs/js/module/expression/logical_expression.js.snap
@@ -269,12 +269,7 @@ const a =
 lorem && // foo
 	ipsum;
 
-lorem &&
-	call_function(
-		1,
-		3,
-	) // foo
-	;
+lorem && call_function(1, 3); // foo
 
 lorem &&
 	// foo
diff --git a/crates/rome_js_formatter/tests/specs/js/module/expression/static_member_expression.js.snap b/crates/rome_js_formatter/tests/specs/js/module/expression/static_member_expression.js.snap
index e7f769998eb..40b67388204 100644
--- a/crates/rome_js_formatter/tests/specs/js/module/expression/static_member_expression.js.snap
+++ b/crates/rome_js_formatter/tests/specs/js/module/expression/static_member_expression.js.snap
@@ -46,8 +46,7 @@ lorem()[0]().ipsum().looooooooooooooooooooooooooong().looooooooooooooooooooooooo
 
 something()[1]()[3]().items.item.what_else[3]().something().something().then().catcht().else().what_the_hell();
 
-some.member.with
-	.
+some.member.with.
 	// rome-ignore format: Verify that formatting calls into right.format()
 	rather.hard.to.test.because.name.doesnt.format.being.ignored;
 
diff --git a/crates/rome_js_formatter/tests/specs/js/module/function/function_comments.js.snap b/crates/rome_js_formatter/tests/specs/js/module/function/function_comments.js.snap
index 797d5f6266b..5c3679c49c7 100644
--- a/crates/rome_js_formatter/tests/specs/js/module/function/function_comments.js.snap
+++ b/crates/rome_js_formatter/tests/specs/js/module/function/function_comments.js.snap
@@ -32,6 +32,7 @@ Quote properties: As needed
 function a() {
 	// trailing comment
 	let a = 2;
+
 	/** leading comment **/
 }
 
diff --git a/crates/rome_js_formatter/tests/specs/js/module/import/bare_import.js b/crates/rome_js_formatter/tests/specs/js/module/import/bare_import.js
index f3b3c795033..f424f1f08eb 100644
--- a/crates/rome_js_formatter/tests/specs/js/module/import/bare_import.js
+++ b/crates/rome_js_formatter/tests/specs/js/module/import/bare_import.js
@@ -11,10 +11,13 @@ import "very_long_import_very_long_import_very" assert {
         }
 
 import "very_long_import_very_long_import_very" assert {
-        // something good is here
-        "type": /****/ "json",
-        "type2": /****/ "json",
-        "type3": /****/ "json",
-        "type4": /****/ "json",
-        "typetypetypetypetypetypetypetypetypetypetype": /****/ "typetypetypetypetypetypetypetypetypetypetypetypetypetype",
-        }
\ No newline at end of file
+		// something good is here
+		"type": /****/ "json",
+		"type2" /****/ : "json",
+		/****/
+		"type4" /* dangling 1 */: /* danling 2 */ // line
+			"json",
+		/****/
+		"typetypetypetypetypetypetypetypetypetypetype": /****/ "typetypetypetypetypetypetypetypetypetypetypetypetypetype",
+		}
+
diff --git a/crates/rome_js_formatter/tests/specs/js/module/import/bare_import.js.snap b/crates/rome_js_formatter/tests/specs/js/module/import/bare_import.js.snap
index b9e41a59712..90e80384c22 100644
--- a/crates/rome_js_formatter/tests/specs/js/module/import/bare_import.js.snap
+++ b/crates/rome_js_formatter/tests/specs/js/module/import/bare_import.js.snap
@@ -16,13 +16,17 @@ import "very_long_import_very_long_import_very" assert {
         }
 
 import "very_long_import_very_long_import_very" assert {
-        // something good is here
-        "type": /****/ "json",
-        "type2": /****/ "json",
-        "type3": /****/ "json",
-        "type4": /****/ "json",
-        "typetypetypetypetypetypetypetypetypetypetype": /****/ "typetypetypetypetypetypetypetypetypetypetypetypetypetype",
-        }
+		// something good is here
+		"type": /****/ "json",
+		"type2" /****/ : "json",
+		/****/
+		"type4" /* dangling 1 */: /* danling 2 */ // line
+			"json",
+		/****/
+		"typetypetypetypetypetypetypetypetypetypetype": /****/ "typetypetypetypetypetypetypetypetypetypetypetypetypetype",
+		}
+
+
 =============================
 # Outputs
 ## Output 1
@@ -47,8 +51,10 @@ import "very_long_import_very_long_import_very" assert {
 	// something good is here
 	"type": /****/ "json",
 	"type2": /****/ "json",
-	"type3": /****/ "json",
-	"type4": /****/ "json",
+	/****/
+	/* dangling 1 */ /* danling 2 */ // line
+	"type4": "json",
+	/****/
 	"typetypetypetypetypetypetypetypetypetypetype": /****/ "typetypetypetypetypetypetypetypetypetypetypetypetypetype",
 };
 
@@ -57,5 +63,5 @@ import "very_long_import_very_long_import_very" assert {
 
     1: import "very_long_import_very_long_import_very_long_import_very_long_import_very_long_import_very_long_import_very_long_import_";
     2: import "very_long_import_very_long_import_very_long_import_very_long_import_very_long_import_very_long" assert {
-   18: 	"typetypetypetypetypetypetypetypetypetypetype": /****/ "typetypetypetypetypetypetypetypetypetypetypetypetypetype",
+   20: 	"typetypetypetypetypetypetypetypetypetypetype": /****/ "typetypetypetypetypetypetypetypetypetypetypetypetypetype",
 
diff --git a/crates/rome_js_formatter/tests/specs/js/module/number/number_with_space.js.snap b/crates/rome_js_formatter/tests/specs/js/module/number/number_with_space.js.snap
index 30a88287281..fb7b5aa9813 100644
--- a/crates/rome_js_formatter/tests/specs/js/module/number/number_with_space.js.snap
+++ b/crates/rome_js_formatter/tests/specs/js/module/number/number_with_space.js.snap
@@ -20,8 +20,7 @@ Quote style: Double Quotes
 Quote properties: As needed
 -----
 (123).toString;
-(123)
-	/****/.toString;
+/****/ (123).toString;
 (123) /**/.toString;
 (123).toString;
 
diff --git a/crates/rome_js_formatter/tests/specs/js/module/statement/if_else.js b/crates/rome_js_formatter/tests/specs/js/module/statement/if_else.js
index 17ba0a95224..e5b34d6592c 100644
--- a/crates/rome_js_formatter/tests/specs/js/module/statement/if_else.js
+++ b/crates/rome_js_formatter/tests/specs/js/module/statement/if_else.js
@@ -62,5 +62,8 @@ if (true) {
 if (true) that(); else;
 
 if (true) {}
-// rome-ignore format: Test suppression comments
-else     if (true &&  false) {}
+else     if (
+	// rome-ignore format: Test suppression comments
+
+true &&  false
+) {}
diff --git a/crates/rome_js_formatter/tests/specs/js/module/statement/if_else.js.snap b/crates/rome_js_formatter/tests/specs/js/module/statement/if_else.js.snap
index 59a2b02ab56..1c5bc31c3fa 100644
--- a/crates/rome_js_formatter/tests/specs/js/module/statement/if_else.js.snap
+++ b/crates/rome_js_formatter/tests/specs/js/module/statement/if_else.js.snap
@@ -67,8 +67,11 @@ if (true) {
 if (true) that(); else;
 
 if (true) {}
-// rome-ignore format: Test suppression comments
-else     if (true &&  false) {}
+else     if (
+	// rome-ignore format: Test suppression comments
+
+true &&  false
+) {}
 
 =============================
 # Outputs
@@ -128,7 +131,6 @@ if (true) {
 
 if (true) {
 	// trailing
-
 } else {
 	// trailing
 }
@@ -137,7 +139,10 @@ if (true) that();
 else;
 
 if (true) {
+} else if (
+	// rome-ignore format: Test suppression comments
+
+	true &&  false
+) {
 }
-// rome-ignore format: Test suppression comments
-else     if (true &&  false) {}
 
diff --git a/crates/rome_js_formatter/tests/specs/js/module/statement/switch.js.snap b/crates/rome_js_formatter/tests/specs/js/module/statement/switch.js.snap
index d3944f17b0f..4b0da0858bb 100644
--- a/crates/rome_js_formatter/tests/specs/js/module/statement/switch.js.snap
+++ b/crates/rome_js_formatter/tests/specs/js/module/statement/switch.js.snap
@@ -33,7 +33,8 @@ Quote style: Double Quotes
 Quote properties: As needed
 -----
 switch (key) {
-	case value: // comment
+	case // comment
+	value:
 
 	case value:
 	// fallthrough
diff --git a/crates/rome_js_formatter/tests/specs/js/module/suppression.js.snap b/crates/rome_js_formatter/tests/specs/js/module/suppression.js.snap
index b4f92e16543..277bca9f04c 100644
--- a/crates/rome_js_formatter/tests/specs/js/module/suppression.js.snap
+++ b/crates/rome_js_formatter/tests/specs/js/module/suppression.js.snap
@@ -54,7 +54,7 @@ if (true) statement();
 
 const expr =
 	// rome-ignore format: the array should not be formatted
-[
+	[
     (2*n)/(r-l), 0,            (r+l)/(r-l),  0,
     0,           (2*n)/(t-b),  (t+b)/(t-b),  0,
     0,           0,           -(f+n)/(f-n), -(2*f*n)/(f-n),
@@ -64,10 +64,10 @@ const expr =
 const expr2 = {
 	key:
 		// rome-ignore format: only skip formatting the value
-        'single quoted string',
+		'single quoted string',
 };
 
 let a =
 	// rome-ignore format: test
-function () {};
+	function () {};
 
diff --git a/crates/rome_js_formatter/tests/specs/js/module/template/template.js.snap b/crates/rome_js_formatter/tests/specs/js/module/template/template.js.snap
index b9c7d7a3c07..da9d219a446 100644
--- a/crates/rome_js_formatter/tests/specs/js/module/template/template.js.snap
+++ b/crates/rome_js_formatter/tests/specs/js/module/template/template.js.snap
@@ -126,15 +126,17 @@ const foo = `but where will ${
 
 `<div>${
 	this.set && this.set.artist
-/* avoid console errors if `this.set` is undefined */}</div>`;
+	/* avoid console errors if `this.set` is undefined */
+}</div>`;
 
-`<div>${/* avoid console errors if `this.set` is undefined */
+`<div>${
+	/* avoid console errors if `this.set` is undefined */
 	this.set && this.set.artist
 }</div>`;
 
-`${ExampleStory.getFragment(
+`${
 	// $FlowFixMe found when converting React.createClass to ES6
-	"story",
-)}
+	ExampleStory.getFragment("story")
+}
 `;
 
diff --git a/crates/rome_js_formatter/tests/specs/jsx/attributes.jsx.snap b/crates/rome_js_formatter/tests/specs/jsx/attributes.jsx.snap
index ac681932caf..2ac81fc0795 100644
--- a/crates/rome_js_formatter/tests/specs/jsx/attributes.jsx.snap
+++ b/crates/rome_js_formatter/tests/specs/jsx/attributes.jsx.snap
@@ -142,7 +142,8 @@ let a = (
 <div
 	className={
 		asdf
-	/* comment */asdf }
+		/* comment */
+	asdf }
 />;
 
 // Wrapping JSX in attribute
@@ -164,6 +165,12 @@ const a = (
 );
 
 
+## Unimplemented nodes/tokens
+
+" asd" => 1130..1134
+"\tasd" => 1182..1186
+
+
 ## Lines exceeding width of 80 characters
 
    10: 			"ui-monospace,SFMono-Regular,SF Mono,Consolas,Liberation Mono,Menlo,monospace",
diff --git a/crates/rome_js_formatter/tests/specs/jsx/element.jsx.snap b/crates/rome_js_formatter/tests/specs/jsx/element.jsx.snap
index 7eac0eacc56..9878595dcc7 100644
--- a/crates/rome_js_formatter/tests/specs/jsx/element.jsx.snap
+++ b/crates/rome_js_formatter/tests/specs/jsx/element.jsx.snap
@@ -486,7 +486,8 @@ let a = (
 	<a>
 		{
 			" "
-		/* comment */}
+			/* comment */
+		}
 	</a>
 );
 let a = <a>{/* comment */ " "}</a>;
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/arrays/numbers-negative-comment-after-minus.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/arrays/numbers-negative-comment-after-minus.js.snap
deleted file mode 100644
index 1d330f9dcde..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/js/arrays/numbers-negative-comment-after-minus.js.snap
+++ /dev/null
@@ -1,121 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-const numbers = [-2017,-506252,-744011292,-7224,-70.4,-83353.6,-708.4,-174023963.52,-40385,-// comment1
-380014,
--253951682,-728,-15.84,-2058467564.56,-43,-33,-85134845,-67092,-1,-78820379,-2371.6,-16,7,
-// comment2
--62454,-4282239912,
--10816495.36,0.88,-100622682,8.8,-67087.68000000001,-3758276,-25.5211,-54,-1184265243,-46073628,-280423.44,
--41833463,-27961.12,-305.36,-199875.28];
-
-c = [
-  - /**/ 66, 66, 57, 45, 47, 33, 53, 82, 81, 76, 66, 57, 45, 47, 33, 53, 82, 81, 223323
-];
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -8,10 +8,7 @@
-   -708.4,
-   -174023963.52,
-   -40385,
--  -(
--    // comment1
--    380014
--  ),
-+  -380014, // comment1
-   -253951682,
-   -728,
-   -15.84,
-@@ -46,7 +43,7 @@
- ];
- 
- c = [
--  -(/**/ 66),
-+  - /**/ 66,
-   66,
-   57,
-   45,
-```
-
-# Output
-
-```js
-const numbers = [
-  -2017,
-  -506252,
-  -744011292,
-  -7224,
-  -70.4,
-  -83353.6,
-  -708.4,
-  -174023963.52,
-  -40385,
-  -380014, // comment1
-  -253951682,
-  -728,
-  -15.84,
-  -2058467564.56,
-  -43,
-  -33,
-  -85134845,
-  -67092,
-  -1,
-  -78820379,
-  -2371.6,
-  -16,
-  7,
-  // comment2
-  -62454,
-  -4282239912,
-  -10816495.36,
-  0.88,
-  -100622682,
-  8.8,
-  -67087.68000000001,
-  -3758276,
-  -25.5211,
-  -54,
-  -1184265243,
-  -46073628,
-  -280423.44,
-  -41833463,
-  -27961.12,
-  -305.36,
-  -199875.28,
-];
-
-c = [
-  - /**/ 66,
-  66,
-  57,
-  45,
-  47,
-  33,
-  53,
-  82,
-  81,
-  76,
-  66,
-  57,
-  45,
-  47,
-  33,
-  53,
-  82,
-  81,
-  223323,
-];
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/arrays/numbers-with-holes.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/arrays/numbers-with-holes.js.snap
index 7fe59602e4a..1127852a3d7 100644
--- a/crates/rome_js_formatter/tests/specs/prettier/js/arrays/numbers-with-holes.js.snap
+++ b/crates/rome_js_formatter/tests/specs/prettier/js/arrays/numbers-with-holes.js.snap
@@ -1,5 +1,7 @@
 ---
 source: crates/rome_js_formatter/tests/prettier_tests.rs
+info:
+  test_file: js/arrays/numbers-with-holes.js
 ---
 
 # Input
@@ -42,7 +44,7 @@ const numberWithHoles2 = [
 ```diff
 --- Prettier
 +++ Rome
-@@ -2,8 +2,8 @@
+@@ -2,13 +2,13 @@
    7234932941,
    7234932722,
    7234932312,
@@ -52,6 +54,12 @@ const numberWithHoles2 = [
    7234932841,
    ,
    7234932843,
+-  ,
+   // comment after a hole 1
++  ,
+   7234932436,
+ ];
+ 
 @@ -16,13 +16,13 @@
    0x234932941,
    0x234932722,
@@ -63,9 +71,10 @@ const numberWithHoles2 = [
    0x234932841,
    ,
    0x234932843,
-   ,
-+
+-  ,
    // comment after a hole 2
++  ,
++
    0x234932436,
  ];
 ```
@@ -82,8 +91,8 @@ const numberWithHoles1 = [
   7234932841,
   ,
   7234932843,
-  ,
   // comment after a hole 1
+  ,
   7234932436,
 ];
 
@@ -96,9 +105,9 @@ const numberWithHoles2 = [
   0x234932841,
   ,
   0x234932843,
+  // comment after a hole 2
   ,
 
-  // comment after a hole 2
   0x234932436,
 ];
 ```
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/arrays/numbers-with-tricky-comments.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/arrays/numbers-with-tricky-comments.js.snap
index ef939affd5f..b795c7fb62c 100644
--- a/crates/rome_js_formatter/tests/specs/prettier/js/arrays/numbers-with-tricky-comments.js.snap
+++ b/crates/rome_js_formatter/tests/specs/prettier/js/arrays/numbers-with-tricky-comments.js.snap
@@ -1,5 +1,7 @@
 ---
 source: crates/rome_js_formatter/tests/prettier_tests.rs
+info:
+  test_file: js/arrays/numbers-with-tricky-comments.js
 ---
 
 # Input
@@ -20,11 +22,9 @@ const lazyCatererNumbers =  [1, 2, 4, 7, 11, 16, 22, 29, 37, 46,
 ```diff
 --- Prettier
 +++ Rome
-@@ -1,9 +1,11 @@
- const lazyCatererNumbers = [
+@@ -2,8 +2,10 @@
    1, 2, 4, 7, 11, 16, 22, 29, 37, 46, 56, 67, 79, 92, 106, 121, 137, 154, 172,
--  191, 211, 232, 254, 277, 301, 326, 352, 379, 407, 436, 466 /*block*/,
-+  191, 211, 232, 254, 277, 301, 326, 352, 379, 407, 436, 466, /*block*/
+   191, 211, 232, 254, 277, 301, 326, 352, 379, 407, 436, 466 /*block*/,
    // line
 -  497, 529, 562, 596, 631, 667, 704, 742, 781, 821, 862, 904, 947, 991, 1036,
 -  1082, 1129, 1177, 1226,
@@ -43,7 +43,7 @@ const lazyCatererNumbers =  [1, 2, 4, 7, 11, 16, 22, 29, 37, 46,
 ```js
 const lazyCatererNumbers = [
   1, 2, 4, 7, 11, 16, 22, 29, 37, 46, 56, 67, 79, 92, 106, 121, 137, 154, 172,
-  191, 211, 232, 254, 277, 301, 326, 352, 379, 407, 436, 466, /*block*/
+  191, 211, 232, 254, 277, 301, 326, 352, 379, 407, 436, 466 /*block*/,
   // line
   497,
   529, 562, 596, 631, 667, 704, 742, 781, 821, 862, 904, 947, 991, 1036, 1082,
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/assignment-comments/call.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/assignment-comments/call.js.snap
deleted file mode 100644
index 74afb6109d5..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/js/assignment-comments/call.js.snap
+++ /dev/null
@@ -1,47 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-if (true)
-  if (true)
-    if (true)
-      if (true)
-        if (true)
-          longVariableName1 = // @ts-ignore
-          (variable01 + veryLongVariableNameNumber2).method();
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -3,5 +3,6 @@
-     if (true)
-       if (true)
-         if (true)
--          longVariableName1 = // @ts-ignore
-+          longVariableName1 =
-+            // @ts-ignore
-             (variable01 + veryLongVariableNameNumber2).method();
-```
-
-# Output
-
-```js
-if (true)
-  if (true)
-    if (true)
-      if (true)
-        if (true)
-          longVariableName1 =
-            // @ts-ignore
-            (variable01 + veryLongVariableNameNumber2).method();
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/assignment-comments/call2.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/assignment-comments/call2.js.snap
deleted file mode 100644
index 07e9169dabf..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/js/assignment-comments/call2.js.snap
+++ /dev/null
@@ -1,34 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-const kochabCooieGameOnOboleUnweave = // ???
-      rhubarbRhubarb(annularCooeedSplicesWalksWayWay);
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -1,2 +1,3 @@
--const kochabCooieGameOnOboleUnweave = // ???
-+const kochabCooieGameOnOboleUnweave =
-+  // ???
-   rhubarbRhubarb(annularCooeedSplicesWalksWayWay);
-```
-
-# Output
-
-```js
-const kochabCooieGameOnOboleUnweave =
-  // ???
-  rhubarbRhubarb(annularCooeedSplicesWalksWayWay);
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/assignment-comments/function.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/assignment-comments/function.js.snap
deleted file mode 100644
index 5f3395015d5..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/js/assignment-comments/function.js.snap
+++ /dev/null
@@ -1,200 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-f1 = (
-  a =
-  //comment
-  b
-) => {};
-  
-f2 = (
-  a = //comment
-  b
-) => {};
-  
-f3 = (
-  a =
-  b //comment
-) => {};
-  
-f4 = // Comment
-  () => {};
-
-f5 =
-  
-  // Comment
-  
- () => {}
-  
-f6 = /* comment */
-  
-  // Comment
-  
-  () => {}
-  
-let f1 = (
-  a =
-  //comment
-  b
-) => {};
-  
-let f2 = (
-  a = //comment
-  b
-) => {};
-  
-let f3 = (
-  a =
-  b //comment
-) => {};
-  
-let f4 = // Comment
-  () => {};
-  
-let f5 =
-  
-  // Comment
-  
-  () => {}
-  
-let f6 = /* comment */
-  
-  // Comment
-  
-  () => {}
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -1,6 +1,7 @@
- f1 = (
-+  a =
-   //comment
--  a = b,
-+  b,
- ) => {};
- 
- f2 = (
-@@ -11,7 +12,8 @@
-   a = b, //comment
- ) => {};
- 
--f4 = // Comment
-+f4 =
-+  // Comment
-   () => {};
- 
- f5 =
-@@ -19,16 +21,15 @@
- 
-   () => {};
- 
--f6 =
--  /* comment */
--
-+f6 = /* comment */
-   // Comment
- 
-   () => {};
- 
- let f1 = (
-+  a =
-   //comment
--  a = b,
-+  b,
- ) => {};
- 
- let f2 = (
-@@ -39,7 +40,8 @@
-   a = b, //comment
- ) => {};
- 
--let f4 = // Comment
-+let f4 =
-+  // Comment
-   () => {};
- 
- let f5 =
-@@ -47,9 +49,7 @@
- 
-   () => {};
- 
--let f6 =
--  /* comment */
--
-+let f6 = /* comment */
-   // Comment
- 
-   () => {};
-```
-
-# Output
-
-```js
-f1 = (
-  a =
-  //comment
-  b,
-) => {};
-
-f2 = (
-  a = b, //comment
-) => {};
-
-f3 = (
-  a = b, //comment
-) => {};
-
-f4 =
-  // Comment
-  () => {};
-
-f5 =
-  // Comment
-
-  () => {};
-
-f6 = /* comment */
-  // Comment
-
-  () => {};
-
-let f1 = (
-  a =
-  //comment
-  b,
-) => {};
-
-let f2 = (
-  a = b, //comment
-) => {};
-
-let f3 = (
-  a = b, //comment
-) => {};
-
-let f4 =
-  // Comment
-  () => {};
-
-let f5 =
-  // Comment
-
-  () => {};
-
-let f6 = /* comment */
-  // Comment
-
-  () => {};
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/assignment-comments/identifier.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/assignment-comments/identifier.js.snap
deleted file mode 100644
index 7e750f69a56..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/js/assignment-comments/identifier.js.snap
+++ /dev/null
@@ -1,52 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-const kochabCooieGameOnOboleUnweave = // ???
-      annularCooeedSplicesWalksWayWay;
-
-const bifornCringerMoshedPerplexSawder = // !!!
-  glimseGlyphsHazardNoopsTieTie +
-  averredBathersBoxroomBuggyNurl -
-  anodyneCondosMalateOverateRetinol;
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -1,7 +1,9 @@
--const kochabCooieGameOnOboleUnweave = // ???
-+const kochabCooieGameOnOboleUnweave =
-+  // ???
-   annularCooeedSplicesWalksWayWay;
- 
--const bifornCringerMoshedPerplexSawder = // !!!
-+const bifornCringerMoshedPerplexSawder =
-+  // !!!
-   glimseGlyphsHazardNoopsTieTie +
-   averredBathersBoxroomBuggyNurl -
-   anodyneCondosMalateOverateRetinol;
-```
-
-# Output
-
-```js
-const kochabCooieGameOnOboleUnweave =
-  // ???
-  annularCooeedSplicesWalksWayWay;
-
-const bifornCringerMoshedPerplexSawder =
-  // !!!
-  glimseGlyphsHazardNoopsTieTie +
-  averredBathersBoxroomBuggyNurl -
-  anodyneCondosMalateOverateRetinol;
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/assignment-comments/number.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/assignment-comments/number.js.snap
deleted file mode 100644
index 2ca58c401c6..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/js/assignment-comments/number.js.snap
+++ /dev/null
@@ -1,125 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-fnNumber =
-  // Comment
-  3;
-
-fnNumber =
-
-  // Comment
-
-  3;
-
-fnNumber =
-  // Comment0
-  // Comment1
-  3;
-
-fnNumber = /* comment */
-  3;
-
-fnNumber = /* comments0 */
-  /* comments1 */
-  3;
-
-fnNumber =
-  // Comment
-  3;
-
-var fnNumber =
-
-  // Comment
-
-  3;
-
-var fnNumber =
-  // Comment0
-  // Comment1
-  3;
-
-var fnNumber = /* comment */
-  3;
-
-var fnNumber = /* comments0 */
-  /* comments1 */
-  3;
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -14,8 +14,7 @@
- 
- fnNumber = /* comment */ 3;
- 
--fnNumber =
--  /* comments0 */
-+fnNumber = /* comments0 */
-   /* comments1 */
-   3;
- 
-@@ -35,7 +34,6 @@
- 
- var fnNumber = /* comment */ 3;
- 
--var fnNumber =
--  /* comments0 */
-+var fnNumber = /* comments0 */
-   /* comments1 */
-   3;
-```
-
-# Output
-
-```js
-fnNumber =
-  // Comment
-  3;
-
-fnNumber =
-  // Comment
-
-  3;
-
-fnNumber =
-  // Comment0
-  // Comment1
-  3;
-
-fnNumber = /* comment */ 3;
-
-fnNumber = /* comments0 */
-  /* comments1 */
-  3;
-
-fnNumber =
-  // Comment
-  3;
-
-var fnNumber =
-  // Comment
-
-  3;
-
-var fnNumber =
-  // Comment0
-  // Comment1
-  3;
-
-var fnNumber = /* comment */ 3;
-
-var fnNumber = /* comments0 */
-  /* comments1 */
-  3;
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/assignment-comments/string.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/assignment-comments/string.js.snap
deleted file mode 100644
index 41d18942fb4..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/js/assignment-comments/string.js.snap
+++ /dev/null
@@ -1,202 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-fnString =
-  // Comment
-  'some' + 'long' + 'string';
-
-fnString =
-  // Comment
-
-  'some' + 'long' + 'string';
-
-fnString =
-
-  // Comment
-
-  'some' + 'long' + 'string';
-
-fnString =
-  /* comment */
-  'some' + 'long' + 'string';
-
-fnString =
-  /**
-   * multi-line
-   */
-  'some' + 'long' + 'string';
-
-fnString =
-  /* inline */ 'some' + 'long' + 'string' + 'some' + 'long' + 'string' + 'some' + 'long' + 'string' + 'some' + 'long' + 'string';
-
-fnString = // Comment0
-  // Comment1
-  'some' + 'long' + 'string';
-
-fnString = // Comment
-  'some' + 'long' + 'string';
-
-fnString =
-  // Comment
-  'some' + 'long' + 'string';
-
-var fnString =
-  // Comment
-
-  'some' + 'long' + 'string';
-
-var fnString =
-
-  // Comment
-
-  'some' + 'long' + 'string';
-
-var fnString =
-  /* comment */
-  'some' + 'long' + 'string';
-
-var fnString =
-  /**
-   * multi-line
-   */
-  'some' + 'long' + 'string';
-
-var fnString =
-  /* inline */ 'some' + 'long' + 'string' + 'some' + 'long' + 'string' + 'some' + 'long' + 'string' + 'some' + 'long' + 'string';
-
-var fnString = // Comment0
-  // Comment1
-  'some' + 'long' + 'string';
-
-var fnString = // Comment
-  'some' + 'long' + 'string';
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -36,7 +36,8 @@
-   "long" +
-   "string";
- 
--fnString = // Comment0
-+fnString =
-+  // Comment0
-   // Comment1
-   "some" + "long" + "string";
- 
-@@ -80,7 +81,8 @@
-   "long" +
-   "string";
- 
--var fnString = // Comment0
-+var fnString =
-+  // Comment0
-   // Comment1
-   "some" + "long" + "string";
- 
-```
-
-# Output
-
-```js
-fnString =
-  // Comment
-  "some" + "long" + "string";
-
-fnString =
-  // Comment
-
-  "some" + "long" + "string";
-
-fnString =
-  // Comment
-
-  "some" + "long" + "string";
-
-fnString =
-  /* comment */
-  "some" + "long" + "string";
-
-fnString =
-  /**
-   * multi-line
-   */
-  "some" + "long" + "string";
-
-fnString =
-  /* inline */ "some" +
-  "long" +
-  "string" +
-  "some" +
-  "long" +
-  "string" +
-  "some" +
-  "long" +
-  "string" +
-  "some" +
-  "long" +
-  "string";
-
-fnString =
-  // Comment0
-  // Comment1
-  "some" + "long" + "string";
-
-fnString = "some" + "long" + "string"; // Comment
-
-fnString =
-  // Comment
-  "some" + "long" + "string";
-
-var fnString =
-  // Comment
-
-  "some" + "long" + "string";
-
-var fnString =
-  // Comment
-
-  "some" + "long" + "string";
-
-var fnString =
-  /* comment */
-  "some" + "long" + "string";
-
-var fnString =
-  /**
-   * multi-line
-   */
-  "some" + "long" + "string";
-
-var fnString =
-  /* inline */ "some" +
-  "long" +
-  "string" +
-  "some" +
-  "long" +
-  "string" +
-  "some" +
-  "long" +
-  "string" +
-  "some" +
-  "long" +
-  "string";
-
-var fnString =
-  // Comment0
-  // Comment1
-  "some" + "long" + "string";
-
-var fnString = "some" + "long" + "string"; // Comment
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/assignment/lone-arg.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/assignment/lone-arg.js.snap
index 4878cd4a8d8..9598c1f063b 100644
--- a/crates/rome_js_formatter/tests/specs/prettier/js/assignment/lone-arg.js.snap
+++ b/crates/rome_js_formatter/tests/specs/prettier/js/assignment/lone-arg.js.snap
@@ -1,5 +1,7 @@
 ---
 source: crates/rome_js_formatter/tests/prettier_tests.rs
+info:
+  test_file: js/assignment/lone-arg.js
 ---
 
 # Input
@@ -33,15 +35,8 @@ const bifornCringerMoshedPerplexSawderGlyphsHb = someBigFunctionName(`foo
 ```diff
 --- Prettier
 +++ Rome
-@@ -10,10 +10,11 @@
-   someBigFunctionName("foo")("bar");
- 
- if (true) {
--  node.id = this.flowParseTypeAnnotatableIdentifier(
--    /*allowPrimitiveOverride*/ true,
--  );
-+  node.id =
-+    this.flowParseTypeAnnotatableIdentifier(/*allowPrimitiveOverride*/ true);
+@@ -15,5 +15,7 @@
+   );
  }
  
 -const bifornCringerMoshedPerplexSawderGlyphsHb = someBigFunctionName(`foo
@@ -67,8 +62,9 @@ const bifornCringerMoshedPerplexSawderGlyphsHa =
   someBigFunctionName("foo")("bar");
 
 if (true) {
-  node.id =
-    this.flowParseTypeAnnotatableIdentifier(/*allowPrimitiveOverride*/ true);
+  node.id = this.flowParseTypeAnnotatableIdentifier(
+    /*allowPrimitiveOverride*/ true,
+  );
 }
 
 const bifornCringerMoshedPerplexSawderGlyphsHb = someBigFunctionName(
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/babel-plugins/bigint.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/babel-plugins/bigint.js.snap
deleted file mode 100644
index 40b6a48aaa1..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/js/babel-plugins/bigint.js.snap
+++ /dev/null
@@ -1,293 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-// https://github.com/tc39/proposal-bigint
-
-const previousMaxSafe = BigInt(Number.MAX_SAFE_INTEGER);
-// ↪ 9007199254740991
-
-const maxPlusOne = previousMaxSafe + 1n;
-// ↪ 9007199254740992n
-
-const theFuture = previousMaxSafe + 2n;
-// ↪ 9007199254740993n, this works now!
-
-const multi = previousMaxSafe * 2n;
-// ↪ 18014398509481982n
-
-// `–` is not minus sign,
-// SIC https://github.com/tc39/proposal-bigint#operators
-// const subtr = multi – 10n;
-// ↪ 18014398509481972n
-
-const mod = multi % 10n;
-// ↪ 2n
-
-const bigN = 2n ** 54n;
-// ↪ 18014398509481984n
-
-bigN * -1n
-// ↪ –18014398509481984n
-
-0n === 0
-// ↪ false
-
-0n == 0
-// ↪ true
-
-1n < 2
-// ↪ true
-
-2n > 1
-// ↪ true
-
-2 > 2
-// ↪ false
-
-2n > 2
-// ↪ false
-
-2n >= 2
-// ↪ true
-
-const mixed = [4n, 6, -12n, 10, 4, 0, 0n];
-// ↪  [4n, 6, -12n, 10, 4, 0, 0n]
-
-mixed.sort();
-// ↪ [-12n, 0, 0n, 10, 4n, 4, 6]
-
-if (0n) {
-  console.log('Hello from the if!');
-} else {
-  console.log('Hello from the else!');
-}
-
-// ↪ "Hello from the else!"
-
-0n || 12n
-// ↪ 12n
-
-0n && 12n
-// ↪ 0n
-
-Boolean(0n)
-// ↪ false
-
-Boolean(12n)
-// ↪ true
-
-!12n
-// ↪ false
-
-!0n
-// ↪ true
-
-const view = new BigInt64Array(4);
-// ↪ [0n, 0n, 0n, 0n]
-view.length;
-// ↪ 4
-view[0];
-// ↪ 0n
-view[0] = 42n;
-view[0];
-// ↪ 42n
-
-// Highest possible BigInt value that can be represented as a
-// signed 64-bit integer.
-const max = 2n ** (64n - 1n) - 1n;
-view[0] = max;
-view[0];
-// ↪ 9_223_372_036_854_775_807n
-view[0] = max + 1n;
-view[0];
-// ↪ -9_223_372_036_854_775_808n
-//   ^ negative because of overflow
-
-1n + 2
-// ↪ TypeError: Cannot mix BigInt and other types, use explicit conversions
-
-1n * 2
-// ↪ TypeError: Cannot mix BigInt and other types, use explicit conversions
-
-+1n
-// ↪ TypeError: Cannot convert a BigInt value to a number
-
-Number(1n)
-// ↪ 1
-
-1n + '2'
-// ↪ "12"
-
-'2' + 1n
-// ↪ "21"
-
-const badPrecision = BigInt(9007199254740993);
-// ↪9007199254740992n
-
-const goodPrecision = BigInt('9007199254740993');
-// ↪9007199254740993n
-
-const alsoGoodPrecision = 9007199254740993n;
-// ↪9007199254740993n
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -103,9 +103,10 @@
- 1n + 2;
- // ↪ TypeError: Cannot mix BigInt and other types, use explicit conversions
- 
--1n * 2 +
-+1n * 2
-   // ↪ TypeError: Cannot mix BigInt and other types, use explicit conversions
- 
-+  +
-   1n;
- // ↪ TypeError: Cannot convert a BigInt value to a number
- 
-```
-
-# Output
-
-```js
-// https://github.com/tc39/proposal-bigint
-
-const previousMaxSafe = BigInt(Number.MAX_SAFE_INTEGER);
-// ↪ 9007199254740991
-
-const maxPlusOne = previousMaxSafe + 1n;
-// ↪ 9007199254740992n
-
-const theFuture = previousMaxSafe + 2n;
-// ↪ 9007199254740993n, this works now!
-
-const multi = previousMaxSafe * 2n;
-// ↪ 18014398509481982n
-
-// `–` is not minus sign,
-// SIC https://github.com/tc39/proposal-bigint#operators
-// const subtr = multi – 10n;
-// ↪ 18014398509481972n
-
-const mod = multi % 10n;
-// ↪ 2n
-
-const bigN = 2n ** 54n;
-// ↪ 18014398509481984n
-
-bigN * -1n;
-// ↪ –18014398509481984n
-
-0n === 0;
-// ↪ false
-
-0n == 0;
-// ↪ true
-
-1n < 2;
-// ↪ true
-
-2n > 1;
-// ↪ true
-
-2 > 2;
-// ↪ false
-
-2n > 2;
-// ↪ false
-
-2n >= 2;
-// ↪ true
-
-const mixed = [4n, 6, -12n, 10, 4, 0, 0n];
-// ↪  [4n, 6, -12n, 10, 4, 0, 0n]
-
-mixed.sort();
-// ↪ [-12n, 0, 0n, 10, 4n, 4, 6]
-
-if (0n) {
-  console.log("Hello from the if!");
-} else {
-  console.log("Hello from the else!");
-}
-
-// ↪ "Hello from the else!"
-
-0n || 12n;
-// ↪ 12n
-
-0n && 12n;
-// ↪ 0n
-
-Boolean(0n);
-// ↪ false
-
-Boolean(12n);
-// ↪ true
-
-!12n;
-// ↪ false
-
-!0n;
-// ↪ true
-
-const view = new BigInt64Array(4);
-// ↪ [0n, 0n, 0n, 0n]
-view.length;
-// ↪ 4
-view[0];
-// ↪ 0n
-view[0] = 42n;
-view[0];
-// ↪ 42n
-
-// Highest possible BigInt value that can be represented as a
-// signed 64-bit integer.
-const max = 2n ** (64n - 1n) - 1n;
-view[0] = max;
-view[0];
-// ↪ 9_223_372_036_854_775_807n
-view[0] = max + 1n;
-view[0];
-// ↪ -9_223_372_036_854_775_808n
-//   ^ negative because of overflow
-
-1n + 2;
-// ↪ TypeError: Cannot mix BigInt and other types, use explicit conversions
-
-1n * 2
-  // ↪ TypeError: Cannot mix BigInt and other types, use explicit conversions
-
-  +
-  1n;
-// ↪ TypeError: Cannot convert a BigInt value to a number
-
-Number(1n);
-// ↪ 1
-
-1n + "2";
-// ↪ "12"
-
-"2" + 1n;
-// ↪ "21"
-
-const badPrecision = BigInt(9007199254740993);
-// ↪9007199254740992n
-
-const goodPrecision = BigInt("9007199254740993");
-// ↪9007199254740993n
-
-const alsoGoodPrecision = 9007199254740993n;
-// ↪9007199254740993n
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/babel-plugins/export-default-from.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/babel-plugins/export-default-from.js.snap
index 0c0bc6078f6..775067bafa8 100644
--- a/crates/rome_js_formatter/tests/specs/prettier/js/babel-plugins/export-default-from.js.snap
+++ b/crates/rome_js_formatter/tests/specs/prettier/js/babel-plugins/export-default-from.js.snap
@@ -1,5 +1,7 @@
 ---
 source: crates/rome_js_formatter/tests/prettier_tests.rs
+info:
+  test_file: js/babel-plugins/export-default-from.js
 ---
 
 # Input
@@ -17,11 +19,10 @@ export v from 'mod';
 ```diff
 --- Prettier
 +++ Rome
-@@ -1,3 +1,7 @@
+@@ -1,3 +1,6 @@
  // https://babeljs.io/docs/en/babel-plugin-proposal-export-default-from
  
 -export v from "mod";
-+
 +export
 +v;
 +from;
@@ -33,7 +34,6 @@ export v from 'mod';
 ```js
 // https://babeljs.io/docs/en/babel-plugin-proposal-export-default-from
 
-
 export
 v;
 from;
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/babel-plugins/optional-chaining.js b/crates/rome_js_formatter/tests/specs/prettier/js/babel-plugins/optional-chaining.js
index f013537cdce..d0d5842054e 100644
--- a/crates/rome_js_formatter/tests/specs/prettier/js/babel-plugins/optional-chaining.js
+++ b/crates/rome_js_formatter/tests/specs/prettier/js/babel-plugins/optional-chaining.js
@@ -17,7 +17,6 @@ obj?.foo.bar?.baz; // Only access `foo` if `obj` exists, and `baz` if
                    // `bar` exists
 
 // Example usage with bracket notation:
-// rome-ignore format: https://github.com/rome/tools/issues/2768
 obj?.['foo']?.bar?.baz // 42
 
 const obj2 = {
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/babel-plugins/optional-chaining.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/babel-plugins/optional-chaining.js.snap
deleted file mode 100644
index aef3c7ebeba..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/js/babel-plugins/optional-chaining.js.snap
+++ /dev/null
@@ -1,159 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-// https://babeljs.io/docs/en/babel-plugin-proposal-optional-chaining
-
-const obj = {
-  foo: {
-    bar: {
-      baz: 42,
-    },
-  },
-};
-
-const baz = obj?.foo?.bar?.baz; // 42
-
-const safe = obj?.qux?.baz; // undefined
-
-// Optional chaining and normal chaining can be intermixed
-obj?.foo.bar?.baz; // Only access `foo` if `obj` exists, and `baz` if
-                   // `bar` exists
-
-// Example usage with bracket notation:
-// rome-ignore format: https://github.com/rome/tools/issues/2768
-obj?.['foo']?.bar?.baz // 42
-
-const obj2 = {
-  foo: {
-    bar: {
-      baz() {
-        return 42;
-      },
-    },
-  },
-};
-
-const baz2 = obj?.foo?.bar?.baz(); // 42
-
-const safe3 = obj?.qux?.baz(); // undefined
-const safe4 = obj?.foo.bar.qux?.(); // undefined
-
-const willThrow = obj?.foo.bar.qux(); // Error: not a function
-
-// Top function can be called directly, too.
-function test() {
-  return 42;
-}
-test?.(); // 42
-
-exists?.(); // undefined
-
-const obj3 = {
-  foo: {
-    bar: {
-      baz: class {
-      },
-    },
-  },
-};
-
-const obj4 = {
-  foo: {
-    bar: {}
-  },
-};
-
-const ret = delete obj?.foo?.bar?.baz; // true
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -17,7 +17,8 @@
- // `bar` exists
- 
- // Example usage with bracket notation:
--obj?.["foo"]?.bar?.baz; // 42
-+// rome-ignore format: https://github.com/rome/tools/issues/2768
-+obj?.['foo']?.bar?.baz // 42
- 
- const obj2 = {
-   foo: {
-```
-
-# Output
-
-```js
-// https://babeljs.io/docs/en/babel-plugin-proposal-optional-chaining
-
-const obj = {
-  foo: {
-    bar: {
-      baz: 42,
-    },
-  },
-};
-
-const baz = obj?.foo?.bar?.baz; // 42
-
-const safe = obj?.qux?.baz; // undefined
-
-// Optional chaining and normal chaining can be intermixed
-obj?.foo.bar?.baz; // Only access `foo` if `obj` exists, and `baz` if
-// `bar` exists
-
-// Example usage with bracket notation:
-// rome-ignore format: https://github.com/rome/tools/issues/2768
-obj?.['foo']?.bar?.baz // 42
-
-const obj2 = {
-  foo: {
-    bar: {
-      baz() {
-        return 42;
-      },
-    },
-  },
-};
-
-const baz2 = obj?.foo?.bar?.baz(); // 42
-
-const safe3 = obj?.qux?.baz(); // undefined
-const safe4 = obj?.foo.bar.qux?.(); // undefined
-
-const willThrow = obj?.foo.bar.qux(); // Error: not a function
-
-// Top function can be called directly, too.
-function test() {
-  return 42;
-}
-test?.(); // 42
-
-exists?.(); // undefined
-
-const obj3 = {
-  foo: {
-    bar: {
-      baz: class {},
-    },
-  },
-};
-
-const obj4 = {
-  foo: {
-    bar: {},
-  },
-};
-
-const ret = delete obj?.foo?.bar?.baz; // true
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/babel-plugins/pipeline-operator-hack.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/babel-plugins/pipeline-operator-hack.js.snap
index 04f9036d7e4..dc26aaf9dd0 100644
--- a/crates/rome_js_formatter/tests/specs/prettier/js/babel-plugins/pipeline-operator-hack.js.snap
+++ b/crates/rome_js_formatter/tests/specs/prettier/js/babel-plugins/pipeline-operator-hack.js.snap
@@ -1,5 +1,7 @@
 ---
 source: crates/rome_js_formatter/tests/prettier_tests.rs
+info:
+  test_file: js/babel-plugins/pipeline-operator-hack.js
 ---
 
 # Input
@@ -21,15 +23,15 @@ return list
 ```diff
 --- Prettier
 +++ Rome
-@@ -1,6 +1,7 @@
+@@ -1,6 +1,8 @@
  // https://babeljs.io/docs/en/babel-plugin-proposal-pipeline-operator
  // https://github.com/js-choi/proposal-hack-pipes
  
 -return list |> take(prefix.length, %) |> equals(%, prefix);
--
 +return list
 + |> take(prefix.length, %)
 + |> equals(%, prefix);
+ 
  // (The % token isn't final; it might instead be @ or ? or #.)
 ```
 
@@ -42,6 +44,7 @@ return list
 return list
  |> take(prefix.length, %)
  |> equals(%, prefix);
+
 // (The % token isn't final; it might instead be @ or ? or #.)
 ```
 
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/babel-plugins/private-fields-in-in.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/babel-plugins/private-fields-in-in.js.snap
deleted file mode 100644
index d4651c39ac0..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/js/babel-plugins/private-fields-in-in.js.snap
+++ /dev/null
@@ -1,141 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-// https://github.com/tc39/proposal-private-fields-in-in
-
-class C {
-  #brand;
-
-  static isC(obj) {
-    try {
-      obj.#brand;
-      return true;
-    } catch {
-      return false;
-    }
-  }
-}
-
-class C2 {
-  #data = null; // populated later
-
-  get #getter() {
-    if (!this.#data) {
-      throw new Error('no data yet!');
-    }
-    return this.#data;
-  }
-
-  static isC(obj) {
-    try {
-      obj.#getter;
-      return true;
-    } catch {
-      return false; // oops! might have gotten here because `#getter` threw :-(
-    }
-  }
-}
-
-class C3 {
-  #brand;
-
-  #method() {}
-
-  get #getter() {}
-
-  static isC(obj) {
-    return #brand in obj && #method in obj && #getter in obj;
-  }
-}
-
-// Invalid https://github.com/tc39/proposal-private-fields-in-in#try-statement
-// class C {
-//   #brand;
-
-//   static isC(obj) {
-//     return try obj.#brand;
-//   }
-// }
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -44,7 +44,6 @@
-     return #brand in obj && #method in obj && #getter in obj;
-   }
- }
--
- // Invalid https://github.com/tc39/proposal-private-fields-in-in#try-statement
- // class C {
- //   #brand;
-```
-
-# Output
-
-```js
-// https://github.com/tc39/proposal-private-fields-in-in
-
-class C {
-  #brand;
-
-  static isC(obj) {
-    try {
-      obj.#brand;
-      return true;
-    } catch {
-      return false;
-    }
-  }
-}
-
-class C2 {
-  #data = null; // populated later
-
-  get #getter() {
-    if (!this.#data) {
-      throw new Error("no data yet!");
-    }
-    return this.#data;
-  }
-
-  static isC(obj) {
-    try {
-      obj.#getter;
-      return true;
-    } catch {
-      return false; // oops! might have gotten here because `#getter` threw :-(
-    }
-  }
-}
-
-class C3 {
-  #brand;
-
-  #method() {}
-
-  get #getter() {}
-
-  static isC(obj) {
-    return #brand in obj && #method in obj && #getter in obj;
-  }
-}
-// Invalid https://github.com/tc39/proposal-private-fields-in-in#try-statement
-// class C {
-//   #brand;
-
-//   static isC(obj) {
-//     return try obj.#brand;
-//   }
-// }
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/break-calls/react.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/break-calls/react.js.snap
index 88f82d61260..62cbdfb792e 100644
--- a/crates/rome_js_formatter/tests/specs/prettier/js/break-calls/react.js.snap
+++ b/crates/rome_js_formatter/tests/specs/prettier/js/break-calls/react.js.snap
@@ -1,5 +1,7 @@
 ---
 source: crates/rome_js_formatter/tests/prettier_tests.rs
+info:
+  test_file: js/break-calls/react.js
 ---
 
 # Input
@@ -77,29 +79,15 @@ function Comp5() {
 ```diff
 --- Prettier
 +++ Rome
-@@ -41,64 +41,66 @@
- }
- 
- function MyComponent(props) {
--  useEffect(
--    () => {
--      console.log("some code", props.foo);
--    },
+@@ -45,7 +45,6 @@
+     () => {
+       console.log("some code", props.foo);
+     },
 -
--    // We need to disable the eslint warning here,
--    // because of some complicated reason.
--    // eslint-disable line react-hooks/exhaustive-deps
--    [],
--  );
-+  useEffect(() => {
-+    console.log("some code", props.foo);
-+  },
-+  // We need to disable the eslint warning here,
-+  // because of some complicated reason.
-+  // eslint-disable line react-hooks/exhaustive-deps
-+  []);
- 
-   return null;
+     // We need to disable the eslint warning here,
+     // because of some complicated reason.
+     // eslint-disable line react-hooks/exhaustive-deps
+@@ -56,49 +55,54 @@
  }
  
  function Comp1() {
@@ -236,13 +224,15 @@ function helloWorldWithReact() {
 }
 
 function MyComponent(props) {
-  useEffect(() => {
-    console.log("some code", props.foo);
-  },
-  // We need to disable the eslint warning here,
-  // because of some complicated reason.
-  // eslint-disable line react-hooks/exhaustive-deps
-  []);
+  useEffect(
+    () => {
+      console.log("some code", props.foo);
+    },
+    // We need to disable the eslint warning here,
+    // because of some complicated reason.
+    // eslint-disable line react-hooks/exhaustive-deps
+    [],
+  );
 
   return null;
 }
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/class-comment/superclass.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/class-comment/superclass.js.snap
deleted file mode 100644
index 8e02f094a34..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/js/class-comment/superclass.js.snap
+++ /dev/null
@@ -1,161 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-class A // comment 1
-  // comment 2
-  extends B {}
-
-class A1 extends B // comment1
-// comment2
-// comment3
-{}
-
-class A2 /* a */ extends B {}
-class A3 extends B /* a */ {}
-class A4 extends /* a */ B {}
-
-(class A5 // comment 1
-  // comment 2
-  extends B {});
-
-(class A6 extends B // comment1
-// comment2
-// comment3
-{});
-
-(class A7 /* a */ extends B {});
-(class A8 extends B /* a */ {});
-(class A9 extends /* a */ B {});
-
-class a extends b // comment
-{
-  constructor() {}
-}
-
-class c extends d
-// comment2
-{
-  constructor() {}
-}
-
-class C2  // comment
-extends Base
-{  foo(){} }
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -2,11 +2,11 @@
-   // comment 2
-   extends B {}
- 
--class A1 extends B {
--  // comment1
--  // comment2
--  // comment3
--}
-+class A1
-+  extends B // comment1
-+// comment2
-+// comment3
-+{}
- 
- class A2 /* a */ extends B {}
- class A3 extends B /* a */ {}
-@@ -16,23 +16,25 @@
-   // comment 2
-   extends B {});
- 
--(class A6 extends B {
--  // comment1
--  // comment2
--  // comment3
--});
-+(class A6
-+  extends B // comment1
-+// comment2
-+// comment3
-+{});
- 
- (class A7 /* a */ extends B {});
- (class A8 extends B /* a */ {});
- (class A9 extends /* a */ B {});
- 
--class a extends b {
--  // comment
-+class a
-+  extends b // comment
-+{
-   constructor() {}
- }
- 
--class c extends d {
--  // comment2
-+class c extends d
-+// comment2
-+{
-   constructor() {}
- }
- 
-```
-
-# Output
-
-```js
-class A // comment 1
-  // comment 2
-  extends B {}
-
-class A1
-  extends B // comment1
-// comment2
-// comment3
-{}
-
-class A2 /* a */ extends B {}
-class A3 extends B /* a */ {}
-class A4 extends /* a */ B {}
-
-(class A5 // comment 1
-  // comment 2
-  extends B {});
-
-(class A6
-  extends B // comment1
-// comment2
-// comment3
-{});
-
-(class A7 /* a */ extends B {});
-(class A8 extends B /* a */ {});
-(class A9 extends /* a */ B {});
-
-class a
-  extends b // comment
-{
-  constructor() {}
-}
-
-class c extends d
-// comment2
-{
-  constructor() {}
-}
-
-class C2 // comment
-  extends Base
-{
-  foo() {}
-}
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/classes/method.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/classes/method.js.snap
deleted file mode 100644
index 9459e40814a..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/js/classes/method.js.snap
+++ /dev/null
@@ -1,52 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-
-class C {
-  name/*comment*/() {
-  }
-};
-
-
-({
-  name/*comment*/() {
-  }
-});
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -1,7 +1,7 @@
- class C {
--  name /*comment*/() {}
-+  name /*comment*/ () {}
- }
- 
- ({
--  name /*comment*/() {},
-+  name /*comment*/ () {},
- });
-```
-
-# Output
-
-```js
-class C {
-  name /*comment*/ () {}
-}
-
-({
-  name /*comment*/ () {},
-});
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/comments-closure-typecast/closure-compiler-type-cast.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/comments-closure-typecast/closure-compiler-type-cast.js.snap
index 53686ecb0e7..33463b4d748 100644
--- a/crates/rome_js_formatter/tests/specs/prettier/js/comments-closure-typecast/closure-compiler-type-cast.js.snap
+++ b/crates/rome_js_formatter/tests/specs/prettier/js/comments-closure-typecast/closure-compiler-type-cast.js.snap
@@ -1,5 +1,7 @@
 ---
 source: crates/rome_js_formatter/tests/prettier_tests.rs
+info:
+  test_file: js/comments-closure-typecast/closure-compiler-type-cast.js
 ---
 
 # Input
@@ -73,14 +75,39 @@ const style2 =/**
 ```diff
 --- Prettier
 +++ Rome
-@@ -57,6 +57,6 @@
-  * @type {{
-  *   width: number,
-  * }}
-- */ ({
-+*/ ({
-   width,
- });
+@@ -10,7 +10,8 @@
+ 
+ // preserve parens only for type casts
+ let assignment = /** @type {string} */ (getValue());
+-let value = /** @type {string} */ (this.members[0]).functionCall();
++let value = /** @type {string} */ (this.members[0])
++  .functionCall();
+ 
+ functionCall(1 + /** @type {string} */ (value), /** @type {!Foo} */ ({}));
+ 
+@@ -19,10 +20,18 @@
+ }
+ 
+ // Only numberOrString is typecast
+-var newArray = /** @type {array} */ (numberOrString).map((x) => x);
+-var newArray = /** @type {array} */ (numberOrString).map((x) => x);
+-var newArray = test(/** @type {array} */ (numberOrString).map((x) => x));
+-var newArray = test(/** @type {array} */ (numberOrString).map((x) => x));
++var newArray = /** @type {array} */ (numberOrString)
++  .map((x) => x);
++var newArray = /** @type {array} */ (numberOrString)
++  .map((x) => x);
++var newArray = test(
++  /** @type {array} */ (numberOrString)
++    .map((x) => x),
++);
++var newArray = test(
++  /** @type {array} */ (numberOrString)
++    .map((x) => x),
++);
+ 
+ // The numberOrString.map CallExpression is typecast
+ var newArray = /** @type {array} */ (numberOrString.map((x) => x));
 ```
 
 # Output
@@ -98,7 +125,8 @@ let object = {
 
 // preserve parens only for type casts
 let assignment = /** @type {string} */ (getValue());
-let value = /** @type {string} */ (this.members[0]).functionCall();
+let value = /** @type {string} */ (this.members[0])
+  .functionCall();
 
 functionCall(1 + /** @type {string} */ (value), /** @type {!Foo} */ ({}));
 
@@ -107,10 +135,18 @@ function returnValue() {
 }
 
 // Only numberOrString is typecast
-var newArray = /** @type {array} */ (numberOrString).map((x) => x);
-var newArray = /** @type {array} */ (numberOrString).map((x) => x);
-var newArray = test(/** @type {array} */ (numberOrString).map((x) => x));
-var newArray = test(/** @type {array} */ (numberOrString).map((x) => x));
+var newArray = /** @type {array} */ (numberOrString)
+  .map((x) => x);
+var newArray = /** @type {array} */ (numberOrString)
+  .map((x) => x);
+var newArray = test(
+  /** @type {array} */ (numberOrString)
+    .map((x) => x),
+);
+var newArray = test(
+  /** @type {array} */ (numberOrString)
+    .map((x) => x),
+);
 
 // The numberOrString.map CallExpression is typecast
 var newArray = /** @type {array} */ (numberOrString.map((x) => x));
@@ -145,7 +181,7 @@ const style2 = /**
  * @type {{
  *   width: number,
  * }}
-*/ ({
+ */ ({
   width,
 });
 ```
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/comments-closure-typecast/comment-in-the-middle.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/comments-closure-typecast/comment-in-the-middle.js.snap
new file mode 100644
index 00000000000..a5f7b1a5923
--- /dev/null
+++ b/crates/rome_js_formatter/tests/specs/prettier/js/comments-closure-typecast/comment-in-the-middle.js.snap
@@ -0,0 +1,57 @@
+---
+source: crates/rome_js_formatter/tests/prettier_tests.rs
+info:
+  test_file: js/comments-closure-typecast/comment-in-the-middle.js
+---
+
+# Input
+
+```js
+var a =
+/**
+ * bla bla bla
+ * @type {string |
+  * number
+ * }
+* bla bla bla
+ */
+//2
+ ((window['s'])).toString();
+console.log(a.foo());
+```
+
+
+# Prettier differences
+
+```diff
+--- Prettier
++++ Rome
+@@ -7,5 +7,6 @@
+    * bla bla bla
+    */
+   //2
+-  (window["s"]).toString();
++  (window["s"])
++    .toString();
+ console.log(a.foo());
+```
+
+# Output
+
+```js
+var a =
+  /**
+   * bla bla bla
+   * @type {string |
+   * number
+   * }
+   * bla bla bla
+   */
+  //2
+  (window["s"])
+    .toString();
+console.log(a.foo());
+```
+
+
+
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/comments-closure-typecast/comment-placement.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/comments-closure-typecast/comment-placement.js.snap
deleted file mode 100644
index 053c9cf6526..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/js/comments-closure-typecast/comment-placement.js.snap
+++ /dev/null
@@ -1,70 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-const foo1 = /** @type {string} */
-  (value);
-
-const foo2 =
-  /** @type {string} */
-  (value);
-
-const foo3 =
-
-  /** @type {string} */
-  (value);
-
-
-const foo4 =
-  /** @type {string} */(value);
-
-const foo5 =
-  /** @type {string} */ (
-    value
-  );
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -8,6 +8,8 @@
-   /** @type {string} */
-   (value);
- 
--const foo4 = /** @type {string} */ (value);
-+const foo4 =
-+  /** @type {string} */ (value);
- 
--const foo5 = /** @type {string} */ (value);
-+const foo5 =
-+  /** @type {string} */ (value);
-```
-
-# Output
-
-```js
-const foo1 = /** @type {string} */ (value);
-
-const foo2 =
-  /** @type {string} */
-  (value);
-
-const foo3 =
-  /** @type {string} */
-  (value);
-
-const foo4 =
-  /** @type {string} */ (value);
-
-const foo5 =
-  /** @type {string} */ (value);
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/comments-closure-typecast/issue-4124.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/comments-closure-typecast/issue-4124.js.snap
deleted file mode 100644
index 96b30f08c0c..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/js/comments-closure-typecast/issue-4124.js.snap
+++ /dev/null
@@ -1,71 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-/** @type {Object} */(myObject.property).someProp = true;
-(/** @type {Object} */(myObject.property)).someProp = true;
-
-const prop = /** @type {Object} */(myObject.property).someProp;
-
-const test = /** @type (function (*): ?|undefined) */
-      (goog.partial(NewThing.onTemplateChange, rationaleField, typeField));
-
-const test = /** @type (function (*): ?|undefined) */ (goog.partial(NewThing.onTemplateChange, rationaleField, typeField));
-
-const model = /** @type {?{getIndex: Function}} */ (model);
-
-const foo = /** @type {string} */
-  (bar);
-
-const test = /** @type (function (*): ?|undefined) */ (foo);
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -3,9 +3,9 @@
- 
- const prop = /** @type {Object} */ (myObject.property).someProp;
- 
--const test =
--  /** @type (function (*): ?|undefined) */
--  (goog.partial(NewThing.onTemplateChange, rationaleField, typeField));
-+const test = /** @type (function (*): ?|undefined) */ (
-+  goog.partial(NewThing.onTemplateChange, rationaleField, typeField)
-+);
- 
- const test = /** @type (function (*): ?|undefined) */ (
-   goog.partial(NewThing.onTemplateChange, rationaleField, typeField)
-```
-
-# Output
-
-```js
-/** @type {Object} */ (myObject.property).someProp = true;
-/** @type {Object} */ (myObject.property).someProp = true;
-
-const prop = /** @type {Object} */ (myObject.property).someProp;
-
-const test = /** @type (function (*): ?|undefined) */ (
-  goog.partial(NewThing.onTemplateChange, rationaleField, typeField)
-);
-
-const test = /** @type (function (*): ?|undefined) */ (
-  goog.partial(NewThing.onTemplateChange, rationaleField, typeField)
-);
-
-const model = /** @type {?{getIndex: Function}} */ (model);
-
-const foo = /** @type {string} */ (bar);
-
-const test = /** @type (function (*): ?|undefined) */ (foo);
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/comments-closure-typecast/issue-8045.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/comments-closure-typecast/issue-8045.js.snap
deleted file mode 100644
index 94bf9a77f64..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/js/comments-closure-typecast/issue-8045.js.snap
+++ /dev/null
@@ -1,114 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-const myLongVariableName = /** @type {ThisIsAVeryLongTypeThatShouldTriggerLineWrapping} */ (fooBarBaz);
-
-function jsdocCastInReturn() {
-  return /** @type {ThisIsAVeryLongTypeThatShouldTriggerLineWrapping} */ (fooBarBaz);
-}
-
-const myLongVariableName = /** @type {ThisIsAVeryLongTypeThatShouldTriggerLineWrapping} */
-      (fooBarBaz);
-
-function jsdocCastInReturn() {
-  return (/** @type {ThisIsAVeryLongTypeThatShouldTriggerLineWrapping} */
-    (fooBarBaz));
-}
-
-const myLongVariableName = /** @type {ThisIsAVeryLongTypeThatShouldTriggerLineWrapping} */
-      (fooBarBaz);
-
-function jsdocCastInReturn() {
-  return (/** @type {ThisIsAVeryLongTypeThatShouldTriggerLineWrapping} */
-    (fooBarBaz));
-}
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -1,5 +1,5 @@
--const myLongVariableName =
--  /** @type {ThisIsAVeryLongTypeThatShouldTriggerLineWrapping} */ (fooBarBaz);
-+const myLongVariableName = /** @type {ThisIsAVeryLongTypeThatShouldTriggerLineWrapping} */
-+  (fooBarBaz);
- 
- function jsdocCastInReturn() {
-   return /** @type {ThisIsAVeryLongTypeThatShouldTriggerLineWrapping} */ (
-@@ -7,24 +7,20 @@
-   );
- }
- 
--const myLongVariableName =
--  /** @type {ThisIsAVeryLongTypeThatShouldTriggerLineWrapping} */
-+const myLongVariableName = /** @type {ThisIsAVeryLongTypeThatShouldTriggerLineWrapping} */
-   (fooBarBaz);
- 
- function jsdocCastInReturn() {
-   return (
--    /** @type {ThisIsAVeryLongTypeThatShouldTriggerLineWrapping} */
--    (fooBarBaz)
-+    /** @type {ThisIsAVeryLongTypeThatShouldTriggerLineWrapping} */ (fooBarBaz)
-   );
- }
- 
--const myLongVariableName =
--  /** @type {ThisIsAVeryLongTypeThatShouldTriggerLineWrapping} */
-+const myLongVariableName = /** @type {ThisIsAVeryLongTypeThatShouldTriggerLineWrapping} */
-   (fooBarBaz);
- 
- function jsdocCastInReturn() {
-   return (
--    /** @type {ThisIsAVeryLongTypeThatShouldTriggerLineWrapping} */
--    (fooBarBaz)
-+    /** @type {ThisIsAVeryLongTypeThatShouldTriggerLineWrapping} */ (fooBarBaz)
-   );
- }
-```
-
-# Output
-
-```js
-const myLongVariableName = /** @type {ThisIsAVeryLongTypeThatShouldTriggerLineWrapping} */
-  (fooBarBaz);
-
-function jsdocCastInReturn() {
-  return /** @type {ThisIsAVeryLongTypeThatShouldTriggerLineWrapping} */ (
-    fooBarBaz
-  );
-}
-
-const myLongVariableName = /** @type {ThisIsAVeryLongTypeThatShouldTriggerLineWrapping} */
-  (fooBarBaz);
-
-function jsdocCastInReturn() {
-  return (
-    /** @type {ThisIsAVeryLongTypeThatShouldTriggerLineWrapping} */ (fooBarBaz)
-  );
-}
-
-const myLongVariableName = /** @type {ThisIsAVeryLongTypeThatShouldTriggerLineWrapping} */
-  (fooBarBaz);
-
-function jsdocCastInReturn() {
-  return (
-    /** @type {ThisIsAVeryLongTypeThatShouldTriggerLineWrapping} */ (fooBarBaz)
-  );
-}
-```
-
-
-# Lines exceeding max width of 80 characters
-```
-    1: const myLongVariableName = /** @type {ThisIsAVeryLongTypeThatShouldTriggerLineWrapping} */
-   10: const myLongVariableName = /** @type {ThisIsAVeryLongTypeThatShouldTriggerLineWrapping} */
-   19: const myLongVariableName = /** @type {ThisIsAVeryLongTypeThatShouldTriggerLineWrapping} */
-```
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/comments-closure-typecast/object-with-comment.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/comments-closure-typecast/object-with-comment.js.snap
deleted file mode 100644
index 40b34891364..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/js/comments-closure-typecast/object-with-comment.js.snap
+++ /dev/null
@@ -1,58 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-const objectWithComment = /** @type MyType */ (
-  /* comment */
-  {
-    foo: bar
-  }
-);
-
-const objectWithComment2 = /** @type MyType */ (  /* comment */  {
-    foo: bar
-  }
-);
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -5,8 +5,8 @@
-   }
- );
- 
--const objectWithComment2 = /** @type MyType */ (
--  /* comment */ {
-+const objectWithComment2 = /** @type MyType */ (/* comment */
-+  {
-     foo: bar,
-   }
- );
-```
-
-# Output
-
-```js
-const objectWithComment = /** @type MyType */ (
-  /* comment */
-  {
-    foo: bar,
-  }
-);
-
-const objectWithComment2 = /** @type MyType */ (/* comment */
-  {
-    foo: bar,
-  }
-);
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/comments/binary-expressions-block-comments.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/comments/binary-expressions-block-comments.js.snap
deleted file mode 100644
index 03cf52e33b0..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/js/comments/binary-expressions-block-comments.js.snap
+++ /dev/null
@@ -1,183 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-a = b || /** Comment */
-c;
-
-a = b /** Comment */ ||
-c;
-
-a = b || /** TODO this is a very very very very long comment that makes it go > 80 columns */
-c;
-
-a = b /** TODO this is a very very very very long comment that makes it go > 80 columns */ ||
-c;
-
-a = b || /** TODO this is a very very very very long comment that makes it go > 80 columns */ c;
-
-a = b && /** Comment */
-c;
-
-a = b /** Comment */ &&
-c;
-
-a = b && /** TODO this is a very very very very long comment that makes it go > 80 columns */
-c;
-
-a = b /** TODO this is a very very very very long comment that makes it go > 80 columns */ &&
-c;
-
-a = b && /** TODO this is a very very very very long comment that makes it go > 80 columns */ c;
-
-a = b + /** Comment */
-c;
-
-a = b /** Comment */ +
-c;
-
-a = b + /** TODO this is a very very very very long comment that makes it go > 80 columns */
-c;
-
-a = b /** TODO this is a very very very very long comment that makes it go > 80 columns */ +
-c;
-
-a = b + /** TODO this is a very very very very long comment that makes it go > 80 columns */ c;```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -1,9 +1,9 @@
--a = b /** Comment */ || c;
-+a = b || /** Comment */ c;
- 
- a = b /** Comment */ || c;
- 
- a =
--  b /** TODO this is a very very very very long comment that makes it go > 80 columns */ ||
-+  b || /** TODO this is a very very very very long comment that makes it go > 80 columns */
-   c;
- 
- a =
-@@ -11,15 +11,15 @@
-   c;
- 
- a =
--  b ||
--  /** TODO this is a very very very very long comment that makes it go > 80 columns */ c;
-+  b || /** TODO this is a very very very very long comment that makes it go > 80 columns */
-+  c;
- 
--a = b /** Comment */ && c;
-+a = b && /** Comment */ c;
- 
- a = b /** Comment */ && c;
- 
- a =
--  b /** TODO this is a very very very very long comment that makes it go > 80 columns */ &&
-+  b && /** TODO this is a very very very very long comment that makes it go > 80 columns */
-   c;
- 
- a =
-@@ -27,15 +27,15 @@
-   c;
- 
- a =
--  b &&
--  /** TODO this is a very very very very long comment that makes it go > 80 columns */ c;
-+  b && /** TODO this is a very very very very long comment that makes it go > 80 columns */
-+  c;
- 
--a = b /** Comment */ + c;
-+a = b + /** Comment */ c;
- 
- a = b /** Comment */ + c;
- 
- a =
--  b /** TODO this is a very very very very long comment that makes it go > 80 columns */ +
-+  b + /** TODO this is a very very very very long comment that makes it go > 80 columns */
-   c;
- 
- a =
-@@ -43,5 +43,5 @@
-   c;
- 
- a =
--  b +
--  /** TODO this is a very very very very long comment that makes it go > 80 columns */ c;
-+  b + /** TODO this is a very very very very long comment that makes it go > 80 columns */
-+  c;
-```
-
-# Output
-
-```js
-a = b || /** Comment */ c;
-
-a = b /** Comment */ || c;
-
-a =
-  b || /** TODO this is a very very very very long comment that makes it go > 80 columns */
-  c;
-
-a =
-  b /** TODO this is a very very very very long comment that makes it go > 80 columns */ ||
-  c;
-
-a =
-  b || /** TODO this is a very very very very long comment that makes it go > 80 columns */
-  c;
-
-a = b && /** Comment */ c;
-
-a = b /** Comment */ && c;
-
-a =
-  b && /** TODO this is a very very very very long comment that makes it go > 80 columns */
-  c;
-
-a =
-  b /** TODO this is a very very very very long comment that makes it go > 80 columns */ &&
-  c;
-
-a =
-  b && /** TODO this is a very very very very long comment that makes it go > 80 columns */
-  c;
-
-a = b + /** Comment */ c;
-
-a = b /** Comment */ + c;
-
-a =
-  b + /** TODO this is a very very very very long comment that makes it go > 80 columns */
-  c;
-
-a =
-  b /** TODO this is a very very very very long comment that makes it go > 80 columns */ +
-  c;
-
-a =
-  b + /** TODO this is a very very very very long comment that makes it go > 80 columns */
-  c;
-```
-
-
-# Lines exceeding max width of 80 characters
-```
-    6:   b || /** TODO this is a very very very very long comment that makes it go > 80 columns */
-   10:   b /** TODO this is a very very very very long comment that makes it go > 80 columns */ ||
-   14:   b || /** TODO this is a very very very very long comment that makes it go > 80 columns */
-   22:   b && /** TODO this is a very very very very long comment that makes it go > 80 columns */
-   26:   b /** TODO this is a very very very very long comment that makes it go > 80 columns */ &&
-   30:   b && /** TODO this is a very very very very long comment that makes it go > 80 columns */
-   38:   b + /** TODO this is a very very very very long comment that makes it go > 80 columns */
-   42:   b /** TODO this is a very very very very long comment that makes it go > 80 columns */ +
-   46:   b + /** TODO this is a very very very very long comment that makes it go > 80 columns */
-```
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/comments/binary-expressions.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/comments/binary-expressions.js.snap
deleted file mode 100644
index b3bcd2411f5..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/js/comments/binary-expressions.js.snap
+++ /dev/null
@@ -1,274 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-function addition() {
-	0
-	// Comment
-	+ x
-}
-
-function multiplication() {
-	0
-	// Comment
-	* x
-}
-
-function division() {
-	0
-	// Comment
-	/ x
-}
-
-function substraction() {
-	0
-	// Comment
-	- x
-}
-
-function remainder() {
-	0
-	// Comment
-	% x
-}
-
-function exponentiation() {
-	0
-	// Comment
-	** x
-}
-
-function leftShift() {
-	0
-	// Comment
-	<< x
-}
-
-function rightShift() {
-	0
-	// Comment
-	>> x
-}
-
-function unsignedRightShift() {
-	0
-	// Comment
-	>>> x
-}
-
-function bitwiseAnd() {
-	0
-	// Comment
-	& x
-}
-
-function bitwiseOr() {
-	0
-	// Comment
-	| x
-}
-
-function bitwiseXor() {
-	0
-	// Comment
-	^ x
-}
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -1,71 +1,83 @@
- function addition() {
--  0 +
-+  0
-     // Comment
-+    +
-     x;
- }
- 
- function multiplication() {
--  0 *
-+  0
-     // Comment
-+    *
-     x;
- }
- 
- function division() {
--  0 /
-+  0
-     // Comment
-+    /
-     x;
- }
- 
- function substraction() {
--  0 -
-+  0
-     // Comment
-+    -
-     x;
- }
- 
- function remainder() {
--  0 %
-+  0
-     // Comment
-+    %
-     x;
- }
- 
- function exponentiation() {
--  0 **
-+  0
-     // Comment
-+    **
-     x;
- }
- 
- function leftShift() {
--  0 <<
-+  0
-     // Comment
-+    <<
-     x;
- }
- 
- function rightShift() {
--  0 >>
-+  0
-     // Comment
-+    >>
-     x;
- }
- 
- function unsignedRightShift() {
--  0 >>>
-+  0
-     // Comment
-+    >>>
-     x;
- }
- 
- function bitwiseAnd() {
--  0 &
-+  0
-     // Comment
-+    &
-     x;
- }
- 
- function bitwiseOr() {
--  0 |
-+  0
-     // Comment
-+    |
-     x;
- }
- 
- function bitwiseXor() {
--  0 ^
-+  0
-     // Comment
-+    ^
-     x;
- }
-```
-
-# Output
-
-```js
-function addition() {
-  0
-    // Comment
-    +
-    x;
-}
-
-function multiplication() {
-  0
-    // Comment
-    *
-    x;
-}
-
-function division() {
-  0
-    // Comment
-    /
-    x;
-}
-
-function substraction() {
-  0
-    // Comment
-    -
-    x;
-}
-
-function remainder() {
-  0
-    // Comment
-    %
-    x;
-}
-
-function exponentiation() {
-  0
-    // Comment
-    **
-    x;
-}
-
-function leftShift() {
-  0
-    // Comment
-    <<
-    x;
-}
-
-function rightShift() {
-  0
-    // Comment
-    >>
-    x;
-}
-
-function unsignedRightShift() {
-  0
-    // Comment
-    >>>
-    x;
-}
-
-function bitwiseAnd() {
-  0
-    // Comment
-    &
-    x;
-}
-
-function bitwiseOr() {
-  0
-    // Comment
-    |
-    x;
-}
-
-function bitwiseXor() {
-  0
-    // Comment
-    ^
-    x;
-}
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/comments/break-continue-statements.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/comments/break-continue-statements.js.snap
index e03bfa65175..79c6bcae2ba 100644
--- a/crates/rome_js_formatter/tests/specs/prettier/js/comments/break-continue-statements.js.snap
+++ b/crates/rome_js_formatter/tests/specs/prettier/js/comments/break-continue-statements.js.snap
@@ -1,5 +1,7 @@
 ---
 source: crates/rome_js_formatter/tests/prettier_tests.rs
+info:
+  test_file: js/comments/break-continue-statements.js
 ---
 
 # Input
@@ -24,30 +26,34 @@ loop: for (;;) {
 ```diff
 --- Prettier
 +++ Rome
-@@ -1,6 +1,6 @@
- for (;;) {
--  break; /* comment */
--  continue; /* comment */
-+  break /* comment */;
-+  continue /* comment */;
+@@ -4,8 +4,8 @@
  }
  
  loop: for (;;) {
+-  break /* comment */ loop;
+-  break loop /* comment */;
+-  continue /* comment */ loop;
+-  continue loop /* comment */;
++  break loop; /* comment */
++  break loop; /* comment */
++  continue loop; /* comment */
++  continue loop; /* comment */
+ }
 ```
 
 # Output
 
 ```js
 for (;;) {
-  break /* comment */;
-  continue /* comment */;
+  break; /* comment */
+  continue; /* comment */
 }
 
 loop: for (;;) {
-  break /* comment */ loop;
-  break loop /* comment */;
-  continue /* comment */ loop;
-  continue loop /* comment */;
+  break loop; /* comment */
+  break loop; /* comment */
+  continue loop; /* comment */
+  continue loop; /* comment */
 }
 ```
 
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/comments/call_comment.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/comments/call_comment.js.snap
deleted file mode 100644
index c778acfd7af..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/js/comments/call_comment.js.snap
+++ /dev/null
@@ -1,73 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-render( // Warm any cache
-  <ChildUpdates renderAnchor={true} anchorClassOn={true} />,
-  container
-);
-
-React.render( // Warm any cache
-  <ChildUpdates renderAnchor={true} anchorClassOn={true} />,
-  container
-);
-
-render?.( // Warm any cache
-  <ChildUpdates renderAnchor={true} anchorClassOn={true} />,
-  container
-);
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -1,17 +1,14 @@
--render(
--  // Warm any cache
-+render( // Warm any cache
-   <ChildUpdates renderAnchor={true} anchorClassOn={true} />,
-   container,
- );
- 
--React.render(
--  // Warm any cache
-+React.render( // Warm any cache
-   <ChildUpdates renderAnchor={true} anchorClassOn={true} />,
-   container,
- );
- 
--render?.(
--  // Warm any cache
-+render?.( // Warm any cache
-   <ChildUpdates renderAnchor={true} anchorClassOn={true} />,
-   container,
- );
-```
-
-# Output
-
-```js
-render( // Warm any cache
-  <ChildUpdates renderAnchor={true} anchorClassOn={true} />,
-  container,
-);
-
-React.render( // Warm any cache
-  <ChildUpdates renderAnchor={true} anchorClassOn={true} />,
-  container,
-);
-
-render?.( // Warm any cache
-  <ChildUpdates renderAnchor={true} anchorClassOn={true} />,
-  container,
-);
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/comments/dangling.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/comments/dangling.js.snap
deleted file mode 100644
index 873113da5c8..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/js/comments/dangling.js.snap
+++ /dev/null
@@ -1,61 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-var a = {/* dangling */};
-var b = {
-  // dangling
-};
-var b = [/* dangling */];
-function d() {
-  /* dangling */
-}
-new Thing(/* dangling */);
-Thing(/* dangling */);
-export /* dangling */{};
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -1,12 +1,8 @@
--var a = {
--  /* dangling */
--};
-+var a = {/* dangling */};
- var b = {
-   // dangling
- };
--var b = [
--  /* dangling */
--];
-+var b = [/* dangling */];
- function d() {
-   /* dangling */
- }
-```
-
-# Output
-
-```js
-var a = {/* dangling */};
-var b = {
-  // dangling
-};
-var b = [/* dangling */];
-function d() {
-  /* dangling */
-}
-new Thing(/* dangling */);
-Thing(/* dangling */);
-export /* dangling */ {};
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/comments/dangling_for.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/comments/dangling_for.js.snap
deleted file mode 100644
index 72b12a3b226..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/js/comments/dangling_for.js.snap
+++ /dev/null
@@ -1,39 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-for // comment
-(;;);
-
-for /* comment */(;;);
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -1,5 +1,3 @@
--// comment
--for (;;);
-+for (;;); // comment
- 
--/* comment */
--for (;;);
-+for /* comment */ (;;);
-```
-
-# Output
-
-```js
-for (;;); // comment
-
-for /* comment */ (;;);
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/comments/dynamic_imports.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/comments/dynamic_imports.js.snap
index fbf83423129..bed6e52e3a1 100644
--- a/crates/rome_js_formatter/tests/specs/prettier/js/comments/dynamic_imports.js.snap
+++ b/crates/rome_js_formatter/tests/specs/prettier/js/comments/dynamic_imports.js.snap
@@ -1,5 +1,7 @@
 ---
 source: crates/rome_js_formatter/tests/prettier_tests.rs
+info:
+  test_file: js/comments/dynamic_imports.js
 ---
 
 # Input
@@ -32,17 +34,15 @@ wrap(
 ```diff
 --- Prettier
 +++ Rome
-@@ -8,8 +8,8 @@
+@@ -8,7 +8,7 @@
  
  import(
    /* Hello */
 -  "something"
--  /* Hello */
 +  "something",
-+/* Hello */
+   /* Hello */
  );
  
- wrap(import(/* Hello */ "something"));
 ```
 
 # Output
@@ -59,7 +59,7 @@ import("something" /* Hello */ + "else");
 import(
   /* Hello */
   "something",
-/* Hello */
+  /* Hello */
 );
 
 wrap(import(/* Hello */ "something"));
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/comments/export-and-import.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/comments/export-and-import.js.snap
deleted file mode 100644
index 2af128680c9..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/js/comments/export-and-import.js.snap
+++ /dev/null
@@ -1,93 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-// These are tests to compare comment formats in `export` and `import`.
-
-export {
-  foo,
-
-  bar as  // comment
-		 baz,
-} from 'foo'
-
-const fooo = ""
-const barr = ""
-
-export {
-  fooo,
-
-  barr as  // comment
-		 bazz,
-}
-
-import {
-  foo,
-
-  bar as  // comment
-		 baz,
-} from 'foo'
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -2,8 +2,7 @@
- 
- export {
-   foo,
--  // comment
--  bar as baz,
-+  bar as baz, // comment
- } from "foo";
- 
- const fooo = "";
-@@ -11,12 +10,10 @@
- 
- export {
-   fooo,
--  // comment
--  barr as bazz,
-+  barr as bazz, // comment
- };
- 
- import {
-   foo,
--  // comment
--  bar as baz,
-+  bar as baz, // comment
- } from "foo";
-```
-
-# Output
-
-```js
-// These are tests to compare comment formats in `export` and `import`.
-
-export {
-  foo,
-  bar as baz, // comment
-} from "foo";
-
-const fooo = "";
-const barr = "";
-
-export {
-  fooo,
-  barr as bazz, // comment
-};
-
-import {
-  foo,
-  bar as baz, // comment
-} from "foo";
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/comments/export.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/comments/export.js.snap
index 6d70131d25f..5734e41fd5f 100644
--- a/crates/rome_js_formatter/tests/specs/prettier/js/comments/export.js.snap
+++ b/crates/rome_js_formatter/tests/specs/prettier/js/comments/export.js.snap
@@ -1,5 +1,7 @@
 ---
 source: crates/rome_js_formatter/tests/prettier_tests.rs
+info:
+  test_file: js/comments/export.js
 ---
 
 # Input
@@ -53,36 +55,20 @@ export {
 ```diff
 --- Prettier
 +++ Rome
-@@ -1,5 +1,4 @@
--export //comment
+@@ -1,5 +1,5 @@
+ export //comment
 - {};
-+export {}; //comment
++{};
  
  export /* comment */ {};
  
-@@ -25,14 +24,12 @@
- const barrr = "";
- export {
-   foooo,
--  // comment
--  barrr as baz,
-+  barrr as baz, // comment
- } from "foo";
- 
- const fooooo = "";
- const barrrr = "";
- export {
-   fooooo,
--  // comment
--  barrrr as bazz,
-+  barrrr as bazz, // comment
- };
 ```
 
 # Output
 
 ```js
-export {}; //comment
+export //comment
+{};
 
 export /* comment */ {};
 
@@ -108,14 +94,16 @@ const foooo = "";
 const barrr = "";
 export {
   foooo,
-  barrr as baz, // comment
+  // comment
+  barrr as baz,
 } from "foo";
 
 const fooooo = "";
 const barrrr = "";
 export {
   fooooo,
-  barrrr as bazz, // comment
+  // comment
+  barrrr as bazz,
 };
 ```
 
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/comments/function-declaration.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/comments/function-declaration.js.snap
deleted file mode 100644
index 6e2a946131b..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/js/comments/function-declaration.js.snap
+++ /dev/null
@@ -1,215 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-function a(/* comment */) {} // comment
-function b() {} // comment
-function c(/* comment */ argA, argB, argC) {} // comment
-call((/*object*/ row) => {});
-KEYPAD_NUMBERS.map(num => ( // Buttons 0-9
-  <div />
-));
-
-function f1 /* f */() {}
-function f2 (/* args */) {}
-function f3 () /* returns */ {}
-function f4 /* f */(/* args */) /* returns */ {}
-
-function f5 /* f */(/* a */ a) {}
-function f6 /* f */(a /* a */) {}
-function f7 /* f */(/* a */ a) /* returns */ {}
-
-const obj = {
-  f1 /* f */() {},
-  f2 (/* args */) {},
-  f3 () /* returns */ {},
-  f4 /* f */(/* args */) /* returns */ {},
-};
-
-(function f /* f */() {})();
-(function f (/* args */) {})();
-(function f () /* returns */ {})();
-(function f /* f */(/* args */) /* returns */ {})();
-
-class C1 {
-  f/* f */() {}
-}
-class C2 {
-  f(/* args */) {}
-}
-class C3 {
-  f() /* returns */ {}
-}
-class C4 {
-  f/* f */(/* args */) /* returns */ {}
-}
-
-function foo1() 
-// this is a function
-{
-  return 42
-}
-
-function foo2() // this is a function
-{
-  return 42
-}
-
-function foo3() { // this is a function
-  return 42
-}
-
-function foo4() {
-  // this is a function
-  return 42;
-}
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -3,34 +3,35 @@
- function c(/* comment */ argA, argB, argC) {} // comment
- call((/*object*/ row) => {});
- KEYPAD_NUMBERS.map(
--  (
--    num, // Buttons 0-9
--  ) => <div />,
-+  (num) => (
-+    // Buttons 0-9
-+    <div />
-+  ),
- );
- 
--function f1 /* f */() {}
-+function f1 /* f */ () {}
- function f2(/* args */) {}
- function f3() /* returns */ {}
--function f4 /* f */(/* args */) /* returns */ {}
-+function f4 /* f */ (/* args */) /* returns */ {}
- 
--function f5 /* f */(/* a */ a) {}
--function f6 /* f */(a /* a */) {}
--function f7 /* f */(/* a */ a) /* returns */ {}
-+function f5 /* f */ (/* a */ a) {}
-+function f6 /* f */ (a /* a */) {}
-+function f7 /* f */ (/* a */ a) /* returns */ {}
- 
- const obj = {
--  f1 /* f */() {},
-+  f1 /* f */ () {},
-   f2(/* args */) {},
-   f3() /* returns */ {},
--  f4 /* f */(/* args */) /* returns */ {},
-+  f4 /* f */ (/* args */) /* returns */ {},
- };
- 
--(function f /* f */() {})();
-+(function f /* f */ () {})();
- (function f(/* args */) {})();
- (function f() /* returns */ {})();
--(function f /* f */(/* args */) /* returns */ {})();
-+(function f /* f */ (/* args */) /* returns */ {})();
- 
- class C1 {
--  f /* f */() {}
-+  f /* f */ () {}
- }
- class C2 {
-   f(/* args */) {}
-@@ -39,11 +40,12 @@
-   f() /* returns */ {}
- }
- class C4 {
--  f /* f */(/* args */) /* returns */ {}
-+  f /* f */ (/* args */) /* returns */ {}
- }
- 
--function foo1() {
--  // this is a function
-+function foo1()
-+// this is a function
-+{
-   return 42;
- }
- 
-```
-
-# Output
-
-```js
-function a(/* comment */) {} // comment
-function b() {} // comment
-function c(/* comment */ argA, argB, argC) {} // comment
-call((/*object*/ row) => {});
-KEYPAD_NUMBERS.map(
-  (num) => (
-    // Buttons 0-9
-    <div />
-  ),
-);
-
-function f1 /* f */ () {}
-function f2(/* args */) {}
-function f3() /* returns */ {}
-function f4 /* f */ (/* args */) /* returns */ {}
-
-function f5 /* f */ (/* a */ a) {}
-function f6 /* f */ (a /* a */) {}
-function f7 /* f */ (/* a */ a) /* returns */ {}
-
-const obj = {
-  f1 /* f */ () {},
-  f2(/* args */) {},
-  f3() /* returns */ {},
-  f4 /* f */ (/* args */) /* returns */ {},
-};
-
-(function f /* f */ () {})();
-(function f(/* args */) {})();
-(function f() /* returns */ {})();
-(function f /* f */ (/* args */) /* returns */ {})();
-
-class C1 {
-  f /* f */ () {}
-}
-class C2 {
-  f(/* args */) {}
-}
-class C3 {
-  f() /* returns */ {}
-}
-class C4 {
-  f /* f */ (/* args */) /* returns */ {}
-}
-
-function foo1()
-// this is a function
-{
-  return 42;
-}
-
-function foo2() {
-  // this is a function
-  return 42;
-}
-
-function foo3() {
-  // this is a function
-  return 42;
-}
-
-function foo4() {
-  // this is a function
-  return 42;
-}
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/comments/if.js b/crates/rome_js_formatter/tests/specs/prettier/js/comments/if.js
index ff4043ec1a0..47a58e1ed59 100644
--- a/crates/rome_js_formatter/tests/specs/prettier/js/comments/if.js
+++ b/crates/rome_js_formatter/tests/specs/prettier/js/comments/if.js
@@ -43,11 +43,11 @@ else // comment
 if (10) /* comment */ // comment
 {true}
 else if (11) /* comment */
-true
+	true
 else if (12) // comment /* comment */ // comment
-true
+	true
 else if (13) /* comment */ /* comment */ // comment
-true
+	true
 else /* comment */
 {true}
 
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/comments/if.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/comments/if.js.snap
deleted file mode 100644
index cbc2f38d134..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/js/comments/if.js.snap
+++ /dev/null
@@ -1,227 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-if (1)
-// comment
-{
-  false
-}
-// comment
-else if (2)
-  true
-// multi
-// ple
-// lines
-else if (3)
-  // existing comment
-  true
-// okay?
-else if (4) {
-  // empty with existing comment
-}
-// comment
-else {
-}
-
-if (5) // comment
-true
-
-if (6) // comment
-{true}
-else if (7) // comment
-true
-else // comment
-{true}
-
-if (8) // comment
-// comment
-{true}
-else if (9) // comment
-// comment
-true
-else // comment
-// comment
-{true}
-
-if (10) /* comment */ // comment
-{true}
-else if (11) /* comment */
-true
-else if (12) // comment /* comment */ // comment
-true
-else if (13) /* comment */ /* comment */ // comment
-true
-else /* comment */
-{true}
-
-if (14) // comment
-/* comment */
-// comment
-{true}
-else if (15) // comment
-/* comment */
-/* comment */ // comment
-true
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -1,5 +1,6 @@
--if (1) {
--  // comment
-+if (1)
-+// comment
-+{
-   false;
- }
- // comment
-@@ -28,43 +29,43 @@
- } else if (7)
-   // comment
-   true;
--// comment
- else {
-+  // comment
-   true;
- }
- 
--if (8) {
--  // comment
--  // comment
-+if (8) // comment
-+// comment
-+{
-   true;
- } else if (9)
-   // comment
-   // comment
-   true;
--// comment
-+else // comment
- // comment
--else {
-+{
-   true;
- }
- 
--if (10) {
--  /* comment */ // comment
-+if (10) /* comment */ {
-+  // comment
-   true;
- } else if (11) /* comment */ true;
- else if (12)
-   // comment /* comment */ // comment
-   true;
--else if (13)
--  /* comment */ /* comment */ // comment
-+else if (13) /* comment */ /* comment */
-+  // comment
-   true;
--/* comment */ else {
-+else /* comment */ {
-   true;
- }
- 
--if (14) {
--  // comment
--  /* comment */
--  // comment
-+if (14) // comment
-+/* comment */
-+// comment
-+{
-   true;
- } else if (15)
-   // comment
-```
-
-# Output
-
-```js
-if (1)
-// comment
-{
-  false;
-}
-// comment
-else if (2) true;
-// multi
-// ple
-// lines
-else if (3)
-  // existing comment
-  true;
-// okay?
-else if (4) {
-  // empty with existing comment
-}
-// comment
-else {
-}
-
-if (5)
-  // comment
-  true;
-
-if (6) {
-  // comment
-  true;
-} else if (7)
-  // comment
-  true;
-else {
-  // comment
-  true;
-}
-
-if (8) // comment
-// comment
-{
-  true;
-} else if (9)
-  // comment
-  // comment
-  true;
-else // comment
-// comment
-{
-  true;
-}
-
-if (10) /* comment */ {
-  // comment
-  true;
-} else if (11) /* comment */ true;
-else if (12)
-  // comment /* comment */ // comment
-  true;
-else if (13) /* comment */ /* comment */
-  // comment
-  true;
-else /* comment */ {
-  true;
-}
-
-if (14) // comment
-/* comment */
-// comment
-{
-  true;
-} else if (15)
-  // comment
-  /* comment */
-  /* comment */ // comment
-  true;
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/comments/issues.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/comments/issues.js.snap
deleted file mode 100644
index 3d07a8c4ed3..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/js/comments/issues.js.snap
+++ /dev/null
@@ -1,187 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-// Does not need to break as it fits in 80 columns
-this.call(a, /* comment */ b);
-
-// Comments should either stay at the end of the line or always before, but
-// not one before and one after.
-throw new ProcessSystemError({
-  code: acc.error.code, // Alias of errno
-  originalError: acc.error, // Just in case.
-});
-
-// Missing one level of indentation because of the comment
-const rootEpic = (actions, store) => (
-  combineEpics(...epics)(actions, store)
-    // Log errors and continue.
-    .catch((err, stream) => {
-      getLogger().error(err);
-      return stream;
-    })
-);
-
-// optional trailing comma gets moved all the way to the beginning
-const regex = new RegExp(
-  '^\\s*' + // beginning of the line
-  'name\\s*=\\s*' + // name =
-  '[\'"]' + // opening quotation mark
-  escapeStringRegExp(target.name) + // target name
-  '[\'"]' + // closing quotation mark
-  ',?$', // optional trailing comma
-);
-
-// The comment is moved and doesn't trigger the eslint rule anymore
-import path from 'path'; // eslint-disable-line nuclide-internal/prefer-nuclide-uri
-
-// Comments disappear in-between MemberExpressions
-Observable.of(process)
-  // Don't complete until we say so!
-  .merge(Observable.never())
-  // Get the errors.
-  .takeUntil(throwOnError ? errors.flatMap(Observable.throw) : errors)
-  .takeUntil(exit);
-
-// Comments disappear inside of JSX
-<div>
-  {/* Some comment */}
-</div>;
-
-// Comments in JSX tag are placed in a non optimal way
-<div
-  // comment
-/>;
-
-// Comments disappear in empty blocks
-if (1) {
-  // Comment
-}
-
-// Comments trigger invalid JavaScript in-between else if
-if (1) {
-}
-// Comment
-else {
-
-}
-
-// The comment makes the line break in a weird way
-const result = asyncExecute('non_existing_command', /* args */ []);
-
-// The closing paren is printed on the same line as the comment
-foo({}
-  // Hi
-);
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -39,7 +39,9 @@
-   .takeUntil(exit);
- 
- // Comments disappear inside of JSX
--<div>{/* Some comment */}</div>;
-+<div>
-+  {/* Some comment */}
-+</div>;
- 
- // Comments in JSX tag are placed in a non optimal way
- <div
-@@ -64,5 +66,5 @@
- // The closing paren is printed on the same line as the comment
- foo(
-   {},
--  // Hi
-+// Hi
- );
-```
-
-# Output
-
-```js
-// Does not need to break as it fits in 80 columns
-this.call(a, /* comment */ b);
-
-// Comments should either stay at the end of the line or always before, but
-// not one before and one after.
-throw new ProcessSystemError({
-  code: acc.error.code, // Alias of errno
-  originalError: acc.error, // Just in case.
-});
-
-// Missing one level of indentation because of the comment
-const rootEpic = (actions, store) =>
-  combineEpics(...epics)(actions, store)
-    // Log errors and continue.
-    .catch((err, stream) => {
-      getLogger().error(err);
-      return stream;
-    });
-
-// optional trailing comma gets moved all the way to the beginning
-const regex = new RegExp(
-  "^\\s*" + // beginning of the line
-    "name\\s*=\\s*" + // name =
-    "['\"]" + // opening quotation mark
-    escapeStringRegExp(target.name) + // target name
-    "['\"]" + // closing quotation mark
-    ",?$", // optional trailing comma
-);
-
-// The comment is moved and doesn't trigger the eslint rule anymore
-import path from "path"; // eslint-disable-line nuclide-internal/prefer-nuclide-uri
-
-// Comments disappear in-between MemberExpressions
-Observable.of(process)
-  // Don't complete until we say so!
-  .merge(Observable.never())
-  // Get the errors.
-  .takeUntil(throwOnError ? errors.flatMap(Observable.throw) : errors)
-  .takeUntil(exit);
-
-// Comments disappear inside of JSX
-<div>
-  {/* Some comment */}
-</div>;
-
-// Comments in JSX tag are placed in a non optimal way
-<div
-// comment
-/>;
-
-// Comments disappear in empty blocks
-if (1) {
-  // Comment
-}
-
-// Comments trigger invalid JavaScript in-between else if
-if (1) {
-}
-// Comment
-else {
-}
-
-// The comment makes the line break in a weird way
-const result = asyncExecute("non_existing_command", /* args */ []);
-
-// The closing paren is printed on the same line as the comment
-foo(
-  {},
-// Hi
-);
-```
-
-
-# Lines exceeding max width of 80 characters
-```
-   31: import path from "path"; // eslint-disable-line nuclide-internal/prefer-nuclide-uri
-```
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/comments/jsx.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/comments/jsx.js.snap
index 1c9b2476fad..685a26905d8 100644
--- a/crates/rome_js_formatter/tests/specs/prettier/js/comments/jsx.js.snap
+++ b/crates/rome_js_formatter/tests/specs/prettier/js/comments/jsx.js.snap
@@ -1,5 +1,7 @@
 ---
 source: crates/rome_js_formatter/tests/prettier_tests.rs
+info:
+  test_file: js/comments/jsx.js
 ---
 
 # Input
@@ -133,138 +135,41 @@ onClick={() => {}}>
 ```diff
 --- Prettier
 +++ Rome
-@@ -1,24 +1,26 @@
--<div>{/* comment */}</div>;
-+<div>
-+  {
-+  /* comment */
-+  }
-+</div>;
- 
- <div>{/* comment */}</div>;
- 
- <div>
-   {/* comment
--   */}
-+*/}
- </div>;
+@@ -9,8 +9,7 @@
  
  <div>
    {
 -    a
 -    /* comment
--     */
 +    a /* comment
-+*/
-   }
- </div>;
- 
- <div>
--  {
--    /* comment
--     */
-+  {/* comment
-+*/
-     a
+      */
    }
  </div>;
-@@ -29,29 +31,29 @@
- 
- <div>
-   {
--    // single line comment
-+  // single line comment
-   }
- </div>;
- 
- <div>
-   {
--    // multiple line comments 1
--    // multiple line comments 2
-+  // multiple line comments 1
-+  // multiple line comments 2
-   }
- </div>;
- 
- <div>
-   {
--    // multiple mixed comments 1
--    /* multiple mixed comments 2 */
--    /* multiple mixed comments 3 */
--    // multiple mixed comments 4
-+  // multiple mixed comments 1
-+  /* multiple mixed comments 2 */
-+  /* multiple mixed comments 3 */
-+  // multiple mixed comments 4
-   }
- </div>;
- 
- <div>
-   {
--    // Some very v  ery very very merry (xmas) very very long line to break line width limit
-+  // Some very v  ery very very merry (xmas) very very long line to break line width limit
-   }
- </div>;
- 
-@@ -62,13 +64,15 @@
- <div>
-   {/**
-    * JSDoc-y comment in JSX. I wonder what will happen to it?
--   */}
-+  */}
- </div>;
- 
- <div>
--  {/**
-+  {
-+  /**
-    * Another JSDoc comment in JSX.
--   */}
-+   */
-+  }
- </div>;
- 
- <div
-@@ -90,9 +94,8 @@
-   {foo}
- </div>;
- 
--<div
--  className="foo"
--  // comment
-+<div className="foo"
-+// comment
- >
-   {foo}
- </div>;
 ```
 
 # Output
 
 ```js
-<div>
-  {
-  /* comment */
-  }
-</div>;
+<div>{/* comment */}</div>;
 
 <div>{/* comment */}</div>;
 
 <div>
   {/* comment
-*/}
+   */}
 </div>;
 
 <div>
   {
     a /* comment
-*/
+     */
   }
 </div>;
 
 <div>
-  {/* comment
-*/
+  {
+    /* comment
+     */
     a
   }
 </div>;
@@ -275,29 +180,29 @@ onClick={() => {}}>
 
 <div>
   {
-  // single line comment
+    // single line comment
   }
 </div>;
 
 <div>
   {
-  // multiple line comments 1
-  // multiple line comments 2
+    // multiple line comments 1
+    // multiple line comments 2
   }
 </div>;
 
 <div>
   {
-  // multiple mixed comments 1
-  /* multiple mixed comments 2 */
-  /* multiple mixed comments 3 */
-  // multiple mixed comments 4
+    // multiple mixed comments 1
+    /* multiple mixed comments 2 */
+    /* multiple mixed comments 3 */
+    // multiple mixed comments 4
   }
 </div>;
 
 <div>
   {
-  // Some very v  ery very very merry (xmas) very very long line to break line width limit
+    // Some very v  ery very very merry (xmas) very very long line to break line width limit
   }
 </div>;
 
@@ -308,15 +213,13 @@ onClick={() => {}}>
 <div>
   {/**
    * JSDoc-y comment in JSX. I wonder what will happen to it?
-  */}
+   */}
 </div>;
 
 <div>
-  {
-  /**
+  {/**
    * Another JSDoc comment in JSX.
-   */
-  }
+   */}
 </div>;
 
 <div
@@ -338,8 +241,9 @@ onClick={() => {}}>
   {foo}
 </div>;
 
-<div className="foo"
-// comment
+<div
+  className="foo"
+  // comment
 >
   {foo}
 </div>;
@@ -359,7 +263,7 @@ onClick={() => {}}>
 
 # Lines exceeding max width of 80 characters
 ```
-   56:   // Some very v  ery very very merry (xmas) very very long line to break line width limit
-   61:   {/*<div>  Some very v  ery very very long line to break line width limit </div>*/}
+   53:     // Some very v  ery very very merry (xmas) very very long line to break line width limit
+   58:   {/*<div>  Some very v  ery very very long line to break line width limit </div>*/}
 ```
 
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/comments/multi-comments-on-same-line.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/comments/multi-comments-on-same-line.js.snap
index 04de32a96c7..1ec421cabb8 100644
--- a/crates/rome_js_formatter/tests/specs/prettier/js/comments/multi-comments-on-same-line.js.snap
+++ b/crates/rome_js_formatter/tests/specs/prettier/js/comments/multi-comments-on-same-line.js.snap
@@ -1,5 +1,7 @@
 ---
 source: crates/rome_js_formatter/tests/prettier_tests.rs
+info:
+  test_file: js/comments/multi-comments-on-same-line.js
 ---
 
 # Input
@@ -108,9 +110,8 @@ a;/*
  a; /*
 -1*/ /*2*/
 -/*3
-- */
 +1*/ /*2*/ /*3
-+*/
+  */
  b;
  
 -a;
@@ -118,7 +119,7 @@ a;/*
 +a; /*
  1*/ /*2*/ /*3
 - */ b;
-+*/
++ */
 +b;
  
  /*========= First two on same line =========*/
@@ -147,12 +148,12 @@ b;
 
 a; /*
 1*/ /*2*/ /*3
-*/
+ */
 b;
 
 a; /*
 1*/ /*2*/ /*3
-*/
+ */
 b;
 
 /*========= First two on same line =========*/
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/comments/preserve-new-line-last.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/comments/preserve-new-line-last.js.snap
deleted file mode 100644
index 235205204d3..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/js/comments/preserve-new-line-last.js.snap
+++ /dev/null
@@ -1,80 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-function f() {
-  a
-  /* eslint-disable */
-}
-
-function f() {
-  a
-
-  /* eslint-disable */
-}
-
-function name() {
-  // comment1
-  func1()
-
-  // comment2
-  func2()
-
-  // comment3 why func3 commented
-  // func3()
-}
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -5,7 +5,6 @@
- 
- function f() {
-   a;
--
-   /* eslint-disable */
- }
- 
-@@ -15,7 +14,6 @@
- 
-   // comment2
-   func2();
--
-   // comment3 why func3 commented
-   // func3()
- }
-```
-
-# Output
-
-```js
-function f() {
-  a;
-  /* eslint-disable */
-}
-
-function f() {
-  a;
-  /* eslint-disable */
-}
-
-function name() {
-  // comment1
-  func1();
-
-  // comment2
-  func2();
-  // comment3 why func3 commented
-  // func3()
-}
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/comments/return-statement.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/comments/return-statement.js.snap
index 2c9d24ea4c5..1275470ed15 100644
--- a/crates/rome_js_formatter/tests/specs/prettier/js/comments/return-statement.js.snap
+++ b/crates/rome_js_formatter/tests/specs/prettier/js/comments/return-statement.js.snap
@@ -1,5 +1,7 @@
 ---
 source: crates/rome_js_formatter/tests/prettier_tests.rs
+info:
+  test_file: js/comments/return-statement.js
 ---
 
 # Input
@@ -151,15 +153,6 @@ function inlineComment() {
  }
  
  function excessiveEverything() {
-@@ -116,5 +118,7 @@
- }
- 
- function inlineComment() {
--  return /* hi */ 42 || 42;
-+  return (
-+    /* hi */ 42 || 42
-+  );
- }
 ```
 
 # Output
@@ -285,9 +278,7 @@ function taggedTemplate() {
 }
 
 function inlineComment() {
-  return (
-    /* hi */ 42 || 42
-  );
+  return /* hi */ 42 || 42;
 }
 ```
 
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/comments/single-star-jsdoc.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/comments/single-star-jsdoc.js.snap
deleted file mode 100644
index 480a21d665c..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/js/comments/single-star-jsdoc.js.snap
+++ /dev/null
@@ -1,95 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-/*
- * Looking good!
- */
-
-if(true) {
-    /*
-     * Oh no
-     */
-}
-
-  /** first line
-* second line
-   * third line */
-
-  /* first line
-* second line
-   * third line */
-
-  /*! first line
-*second line
-   *  third line */
-
-/*!
-* Extracted from vue codebase
-* https://github.com/vuejs/vue/blob/cfd73c2386623341fdbb3ac636c4baf84ea89c2c/src/compiler/parser/html-parser.js
-* HTML Parser By John Resig (ejohn.org)
-* Modified by Juriy "kangax" Zaytsev
-* Original code by Erik Arvidsson, Mozilla Public License
-* http://erik.eae.net/simplehtmlparser/simplehtmlparser.js
-*/
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -7,7 +7,6 @@
-    * Oh no
-    */
- }
--
- /** first line
-  * second line
-  * third line */
-```
-
-# Output
-
-```js
-/*
- * Looking good!
- */
-
-if (true) {
-  /*
-   * Oh no
-   */
-}
-/** first line
- * second line
- * third line */
-
-/* first line
- * second line
- * third line */
-
-/*! first line
- *second line
- *  third line */
-
-/*!
- * Extracted from vue codebase
- * https://github.com/vuejs/vue/blob/cfd73c2386623341fdbb3ac636c4baf84ea89c2c/src/compiler/parser/html-parser.js
- * HTML Parser By John Resig (ejohn.org)
- * Modified by Juriy "kangax" Zaytsev
- * Original code by Erik Arvidsson, Mozilla Public License
- * http://erik.eae.net/simplehtmlparser/simplehtmlparser.js
- */
-```
-
-
-# Lines exceeding max width of 80 characters
-```
-   24:  * https://github.com/vuejs/vue/blob/cfd73c2386623341fdbb3ac636c4baf84ea89c2c/src/compiler/parser/html-parser.js
-```
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/comments/switch.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/comments/switch.js.snap
deleted file mode 100644
index 30252b9953e..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/js/comments/switch.js.snap
+++ /dev/null
@@ -1,120 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-switch (node && node.type) {
-  case "Property":
-  case "MethodDefinition":
-    prop = node.key;
-    break;
-
-  case "MemberExpression":
-    prop = node.property;
-    break;
-
-  // no default
-}
-
-switch (foo) {
-  case "bar":
-    doThing()
-
-  // no default
-}
-
-switch (foo) {
-  case "bar": //comment
-    doThing(); //comment
-
-  case "baz":
-    doOtherThing(); //comment
-
-}
-
-switch (foo) {
-  case "bar": {
-    doThing();
-  } //comment
-
-  case "baz": {
-    doThing();
-  } //comment
-}
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -7,19 +7,18 @@
-   case "MemberExpression":
-     prop = node.property;
-     break;
--
-   // no default
- }
- 
- switch (foo) {
-   case "bar":
-     doThing();
--
-   // no default
- }
- 
- switch (foo) {
--  case "bar": //comment
-+  case "bar":
-+    //comment
-     doThing(); //comment
- 
-   case "baz":
-```
-
-# Output
-
-```js
-switch (node && node.type) {
-  case "Property":
-  case "MethodDefinition":
-    prop = node.key;
-    break;
-
-  case "MemberExpression":
-    prop = node.property;
-    break;
-  // no default
-}
-
-switch (foo) {
-  case "bar":
-    doThing();
-  // no default
-}
-
-switch (foo) {
-  case "bar":
-    //comment
-    doThing(); //comment
-
-  case "baz":
-    doOtherThing(); //comment
-}
-
-switch (foo) {
-  case "bar": {
-    doThing();
-  } //comment
-
-  case "baz": {
-    doThing();
-  } //comment
-}
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/comments/tagged-template-literal.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/comments/tagged-template-literal.js.snap
index b078a9cd766..5e33ffadabc 100644
--- a/crates/rome_js_formatter/tests/specs/prettier/js/comments/tagged-template-literal.js.snap
+++ b/crates/rome_js_formatter/tests/specs/prettier/js/comments/tagged-template-literal.js.snap
@@ -1,5 +1,7 @@
 ---
 source: crates/rome_js_formatter/tests/prettier_tests.rs
+info:
+  test_file: js/comments/tagged-template-literal.js
 ---
 
 # Input
@@ -33,11 +35,11 @@ foo /* comment */
  `;
  
 -foo/* comment */ `
-+foo /* comment */ `
++foo /* comment */`
  `;
  
 -foo/* comment */ `
-+foo /* comment */ `
++foo /* comment */`
  `;
 ```
 
@@ -53,10 +55,10 @@ foo // comment
 `
 `;
 
-foo /* comment */ `
+foo /* comment */`
 `;
 
-foo /* comment */ `
+foo /* comment */`
 `;
 ```
 
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/comments/template-literal.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/comments/template-literal.js.snap
deleted file mode 100644
index 457e8fc50f4..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/js/comments/template-literal.js.snap
+++ /dev/null
@@ -1,64 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-`
-${a // comment
-}
-
-${b /* comment */}
-
-${/* comment */ c /* comment */}
-
-${// comment
-d //comment
-};
-`
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -1,14 +1,11 @@
- `
--${
--  a // comment
-+${a // comment
- }
- 
- ${b /* comment */}
- 
- ${/* comment */ c /* comment */}
- 
--${
--  // comment
--  d //comment
-+${d // comment //comment
- };
- `;
-```
-
-# Output
-
-```js
-`
-${a // comment
-}
-
-${b /* comment */}
-
-${/* comment */ c /* comment */}
-
-${d // comment //comment
-};
-`;
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/comments/trailing-jsdocs.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/comments/trailing-jsdocs.js.snap
deleted file mode 100644
index 9a97acc9e76..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/js/comments/trailing-jsdocs.js.snap
+++ /dev/null
@@ -1,101 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-const CONNECTION_STATUS = exports.CONNECTION_STATUS = {
-  CLOSED: Object.freeze({ kind: 'CLOSED' }),
-  CONNECTED: Object.freeze({ kind: 'CONNECTED' }),
-  CONNECTING: Object.freeze({ kind: 'CONNECTING' }),
-  NOT_CONNECTED: Object.freeze({ kind: 'NOT_CONNECTED' }) };
-
-/* A comment */ /**
-* A type that can be written to a buffer.
-*/ /**
-* Describes the connection status of a ReactiveSocket/DuplexConnection.
-* - NOT_CONNECTED: no connection established or pending.
-* - CONNECTING: when `connect()` has been called but a connection is not yet
-*   established.
-* - CONNECTED: when a connection is established.
-* - CLOSED: when the connection has been explicitly closed via `close()`.
-* - ERROR: when the connection has been closed for any other reason.
-*/ /**
-* A contract providing different interaction models per the [ReactiveSocket protocol]
-* (https://github.com/ReactiveSocket/reactivesocket/blob/master/Protocol.md).
-*/ /**
-* A single unit of data exchanged between the peers of a `ReactiveSocket`.
-*/
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -4,12 +4,9 @@
-   CONNECTING: Object.freeze({ kind: "CONNECTING" }),
-   NOT_CONNECTED: Object.freeze({ kind: "NOT_CONNECTED" }),
- });
--
--/* A comment */
--/**
-+/* A comment */ /**
-  * A type that can be written to a buffer.
-- */
--/**
-+ */ /**
-  * Describes the connection status of a ReactiveSocket/DuplexConnection.
-  * - NOT_CONNECTED: no connection established or pending.
-  * - CONNECTING: when `connect()` has been called but a connection is not yet
-@@ -17,11 +14,9 @@
-  * - CONNECTED: when a connection is established.
-  * - CLOSED: when the connection has been explicitly closed via `close()`.
-  * - ERROR: when the connection has been closed for any other reason.
-- */
--/**
-+ */ /**
-  * A contract providing different interaction models per the [ReactiveSocket protocol]
-  * (https://github.com/ReactiveSocket/reactivesocket/blob/master/Protocol.md).
-- */
--/**
-+ */ /**
-  * A single unit of data exchanged between the peers of a `ReactiveSocket`.
-  */
-```
-
-# Output
-
-```js
-const CONNECTION_STATUS = (exports.CONNECTION_STATUS = {
-  CLOSED: Object.freeze({ kind: "CLOSED" }),
-  CONNECTED: Object.freeze({ kind: "CONNECTED" }),
-  CONNECTING: Object.freeze({ kind: "CONNECTING" }),
-  NOT_CONNECTED: Object.freeze({ kind: "NOT_CONNECTED" }),
-});
-/* A comment */ /**
- * A type that can be written to a buffer.
- */ /**
- * Describes the connection status of a ReactiveSocket/DuplexConnection.
- * - NOT_CONNECTED: no connection established or pending.
- * - CONNECTING: when `connect()` has been called but a connection is not yet
- *   established.
- * - CONNECTED: when a connection is established.
- * - CLOSED: when the connection has been explicitly closed via `close()`.
- * - ERROR: when the connection has been closed for any other reason.
- */ /**
- * A contract providing different interaction models per the [ReactiveSocket protocol]
- * (https://github.com/ReactiveSocket/reactivesocket/blob/master/Protocol.md).
- */ /**
- * A single unit of data exchanged between the peers of a `ReactiveSocket`.
- */
-```
-
-
-# Lines exceeding max width of 80 characters
-```
-   18:  * A contract providing different interaction models per the [ReactiveSocket protocol]
-```
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/comments/try.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/comments/try.js.snap
deleted file mode 100644
index d92686efb77..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/js/comments/try.js.snap
+++ /dev/null
@@ -1,72 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-// Comment 1
-try { // Comment 2
-  // Comment 3
-}
-// Comment 4
-catch(e) { // Comment 5
-  // Comment 6
-}
-// Comment 7
-finally { // Comment 8
-  // Comment 9
-}
-// Comment 10
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -2,12 +2,14 @@
- try {
-   // Comment 2
-   // Comment 3
--} catch (e) {
--  // Comment 4
-+}
-+// Comment 4
-+catch (e) {
-   // Comment 5
-   // Comment 6
--} finally {
--  // Comment 7
-+}
-+// Comment 7
-+finally {
-   // Comment 8
-   // Comment 9
- }
-```
-
-# Output
-
-```js
-// Comment 1
-try {
-  // Comment 2
-  // Comment 3
-}
-// Comment 4
-catch (e) {
-  // Comment 5
-  // Comment 6
-}
-// Comment 7
-finally {
-  // Comment 8
-  // Comment 9
-}
-// Comment 10
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/comments/variable_declarator.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/comments/variable_declarator.js.snap
deleted file mode 100644
index fd0f24f1ad9..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/js/comments/variable_declarator.js.snap
+++ /dev/null
@@ -1,207 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-let obj1 = // Comment
-{
-  key: 'val'
-}
-
-let obj2 // Comment
-= {
-  key: 'val'
-}
-
-let obj3 = { // Comment
-  key: 'val'
-}
-
-let obj4 = {
-  // Comment
-  key: 'val'
-}
-
-let obj5 = // Comment
-[
-  'val'
-]
-
-let obj6 // Comment
-= [
-  'val'
-]
-
-let obj7 = [ // Comment
-  'val'
-]
-
-let obj8 = [
-  // Comment
-  'val'
-]
-
-let obj9 = // Comment
-`val`;
-
-let obj10 = // Comment
-`
-val
-val
-`;
-
-let obj11 = // Comment
-tag`val`;
-
-let obj12 = // Comment
-tag`
-val
-val
-`;
-
-let // Comment
-  foo1 = 'val';
-
-let // Comment
-  foo2 = 'val',
-  bar = 'val';
-
-const foo3 = 123
-// Nothing to see here.
-;["2", "3"].forEach(x => console.log(x))
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -38,35 +38,31 @@
-   "val",
- ];
- 
--let obj9 =
--  // Comment
--  `val`;
-+let obj9 = // Comment
-+`val`;
- 
--let obj10 =
--  // Comment
--  `
-+let obj10 = // Comment
-+`
- val
- val
- `;
- 
--let obj11 =
--  // Comment
--  tag`val`;
-+let obj11 = tag // Comment
-+`val`;
- 
--let obj12 =
--  // Comment
--  tag`
-+let obj12 = tag // Comment
-+`
- val
- val
- `;
- 
--let // Comment
--  foo1 = "val";
-+let foo1 = "val"; // Comment
- 
--let // Comment
--  foo2 = "val",
-+let foo2 = "val",
-+  // Comment
-   bar = "val";
- 
--const foo3 = 123;
-+const foo3 = 123
- // Nothing to see here.
-+;
- ["2", "3"].forEach((x) => console.log(x));
-```
-
-# Output
-
-```js
-let obj1 =
-  // Comment
-  {
-    key: "val",
-  };
-
-let obj2 =
-  // Comment
-  {
-    key: "val",
-  };
-
-let obj3 = {
-  // Comment
-  key: "val",
-};
-
-let obj4 = {
-  // Comment
-  key: "val",
-};
-
-let obj5 =
-  // Comment
-  ["val"];
-
-let obj6 =
-  // Comment
-  ["val"];
-
-let obj7 = [
-  // Comment
-  "val",
-];
-
-let obj8 = [
-  // Comment
-  "val",
-];
-
-let obj9 = // Comment
-`val`;
-
-let obj10 = // Comment
-`
-val
-val
-`;
-
-let obj11 = tag // Comment
-`val`;
-
-let obj12 = tag // Comment
-`
-val
-val
-`;
-
-let foo1 = "val"; // Comment
-
-let foo2 = "val",
-  // Comment
-  bar = "val";
-
-const foo3 = 123
-// Nothing to see here.
-;
-["2", "3"].forEach((x) => console.log(x));
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/comments/while.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/comments/while.js.snap
deleted file mode 100644
index 5ab99aaa8b2..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/js/comments/while.js.snap
+++ /dev/null
@@ -1,88 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-while(
-    true
-    // Comment
-  ) {}
-
-while(true)// Comment
-{}
-
-while(true){}// Comment
-
-while(true)/*Comment*/{}
-
-while(
-  true // Comment
-  && true // Comment
-  ){}
-
-while(true) {} // comment
-
-while(true) /* comment */ ++x; 
-
-while(1) // Comment
-  foo();
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -3,15 +3,11 @@
-   // Comment
- ) {}
- 
--while (true) {
--  // Comment
--}
-+while (true) {} // Comment
- 
- while (true) {} // Comment
- 
--while (true) {
--  /*Comment*/
--}
-+while (true) /*Comment*/ {}
- 
- while (
-   true && // Comment
-```
-
-# Output
-
-```js
-while (
-  true
-  // Comment
-) {}
-
-while (true) {} // Comment
-
-while (true) {} // Comment
-
-while (true) /*Comment*/ {}
-
-while (
-  true && // Comment
-  true // Comment
-) {}
-
-while (true) {} // comment
-
-while (true) /* comment */ ++x;
-
-while (1)
-  // Comment
-  foo();
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/conditional/comments.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/conditional/comments.js.snap
deleted file mode 100644
index 973a812cc58..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/js/conditional/comments.js.snap
+++ /dev/null
@@ -1,336 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-var inspect = 4 === util.inspect.length
-  ? // node <= 0.8.x
-    (function(v, colors) {
-      return util.inspect(v, void 0, void 0, colors);
-    })
-  : // node > 0.8.x
-    (function(v, colors) {
-      return util.inspect(v, { colors: colors });
-    });
-
-var inspect = 4 === util.inspect.length
-  ? // node <= 0.8.x
-    (function(v, colors) {
-      return util.inspect(v, void 0, void 0, colors);
-    })
-  : // node > 0.8.x
-    (function(v, colors) {
-      return util.inspect(v, { colors: colors });
-    });
-
-const extractTextPluginOptions = shouldUseRelativeAssetPaths
-  // Making sure that the publicPath goes back to to build folder.
-  ? { publicPath: Array(cssFilename.split('/').length).join('../') } :
-  {};
-
-const extractTextPluginOptions2 = shouldUseRelativeAssetPaths
-  ? // Making sure that the publicPath goes back to to build folder.
-    { publicPath: Array(cssFilename.split("/").length).join("../") }
-  : {};
-
-const extractTextPluginOptions3 = shouldUseRelativeAssetPaths // Making sure that the publicPath goes back to to build folder.
-  ? { publicPath: Array(cssFilename.split("/").length).join("../") }
-  : {};
-
-const { configureStore } = process.env.NODE_ENV === "production"
-  ? require("./configureProdStore") // a
-  : require("./configureDevStore"); // b
-
-test /* comment
-  comment
-      comment
-*/
-  ? foo
-  : bar;
-
-test
-  ? /* comment
-          comment
-    comment
-          comment
-  */
-    foo
-  : bar;
-
-test
-  ? /* comment
-       comment
-       comment
-       comment
-    */
-    foo
-  : test
-  ? /* comment
-  comment
-    comment */
-    foo
-  : bar;
-
-test
-  ? /* comment */
-    foo
-  : bar;
-
-test
-  ? foo
-  : /* comment
-         comment
-     comment
-           comment
-    */
-  bar;
-
-test
-  ? foo
-  : /* comment
-         comment
-     comment
-           comment
-    */
-  test
-  ? foo
-  : /* comment
-  comment
-    comment
-   */
-    bar;
-
-test
-  ? foo
-  : /* comment */
-  bar;
-
-test ? test /* c
-c */? foo : bar : bar;
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -1,36 +1,39 @@
- var inspect =
-   4 === util.inspect.length
--    ? // node <= 0.8.x
--      function (v, colors) {
-+    ? function (v, colors) {
-+        // node <= 0.8.x
-         return util.inspect(v, void 0, void 0, colors);
-       }
--    : // node > 0.8.x
--      function (v, colors) {
-+    : function (v, colors) {
-+        // node > 0.8.x
-         return util.inspect(v, { colors: colors });
-       };
- 
- var inspect =
-   4 === util.inspect.length
--    ? // node <= 0.8.x
--      function (v, colors) {
-+    ? function (v, colors) {
-+        // node <= 0.8.x
-         return util.inspect(v, void 0, void 0, colors);
-       }
--    : // node > 0.8.x
--      function (v, colors) {
-+    : function (v, colors) {
-+        // node > 0.8.x
-         return util.inspect(v, { colors: colors });
-       };
- 
- const extractTextPluginOptions = shouldUseRelativeAssetPaths
--  ? // Making sure that the publicPath goes back to to build folder.
--    { publicPath: Array(cssFilename.split("/").length).join("../") }
-+  // Making sure that the publicPath goes back to to build folder.
-+  ? { publicPath: Array(cssFilename.split("/").length).join("../") }
-   : {};
- 
- const extractTextPluginOptions2 = shouldUseRelativeAssetPaths
--  ? // Making sure that the publicPath goes back to to build folder.
--    { publicPath: Array(cssFilename.split("/").length).join("../") }
-+  ? {
-+      // Making sure that the publicPath goes back to to build folder.
-+      publicPath: Array(cssFilename.split("/").length).join("../"),
-+    }
-   : {};
- 
--const extractTextPluginOptions3 = shouldUseRelativeAssetPaths // Making sure that the publicPath goes back to to build folder.
-+const extractTextPluginOptions3 = shouldUseRelativeAssetPaths
-+  // Making sure that the publicPath goes back to to build folder.
-   ? { publicPath: Array(cssFilename.split("/").length).join("../") }
-   : {};
- 
-@@ -51,8 +54,7 @@
-           comment
-     comment
-           comment
--  */
--    foo
-+  */ foo
-   : bar;
- 
- test
-@@ -60,13 +62,11 @@
-        comment
-        comment
-        comment
--    */
--    foo
-+    */ foo
-   : test
-   ? /* comment
-   comment
--    comment */
--    foo
-+    comment */ foo
-   : bar;
- 
- test ? /* comment */ foo : bar;
-@@ -77,8 +77,7 @@
-          comment
-      comment
-            comment
--    */
--    bar;
-+    */ bar;
- 
- test
-   ? foo
-@@ -86,14 +85,12 @@
-          comment
-      comment
-            comment
--    */
--  test
-+    */ test
-   ? foo
-   : /* comment
-   comment
-     comment
--   */
--    bar;
-+   */ bar;
- 
- test ? foo : /* comment */ bar;
- 
-```
-
-# Output
-
-```js
-var inspect =
-  4 === util.inspect.length
-    ? function (v, colors) {
-        // node <= 0.8.x
-        return util.inspect(v, void 0, void 0, colors);
-      }
-    : function (v, colors) {
-        // node > 0.8.x
-        return util.inspect(v, { colors: colors });
-      };
-
-var inspect =
-  4 === util.inspect.length
-    ? function (v, colors) {
-        // node <= 0.8.x
-        return util.inspect(v, void 0, void 0, colors);
-      }
-    : function (v, colors) {
-        // node > 0.8.x
-        return util.inspect(v, { colors: colors });
-      };
-
-const extractTextPluginOptions = shouldUseRelativeAssetPaths
-  // Making sure that the publicPath goes back to to build folder.
-  ? { publicPath: Array(cssFilename.split("/").length).join("../") }
-  : {};
-
-const extractTextPluginOptions2 = shouldUseRelativeAssetPaths
-  ? {
-      // Making sure that the publicPath goes back to to build folder.
-      publicPath: Array(cssFilename.split("/").length).join("../"),
-    }
-  : {};
-
-const extractTextPluginOptions3 = shouldUseRelativeAssetPaths
-  // Making sure that the publicPath goes back to to build folder.
-  ? { publicPath: Array(cssFilename.split("/").length).join("../") }
-  : {};
-
-const { configureStore } =
-  process.env.NODE_ENV === "production"
-    ? require("./configureProdStore") // a
-    : require("./configureDevStore"); // b
-
-test /* comment
-  comment
-      comment
-*/
-  ? foo
-  : bar;
-
-test
-  ? /* comment
-          comment
-    comment
-          comment
-  */ foo
-  : bar;
-
-test
-  ? /* comment
-       comment
-       comment
-       comment
-    */ foo
-  : test
-  ? /* comment
-  comment
-    comment */ foo
-  : bar;
-
-test ? /* comment */ foo : bar;
-
-test
-  ? foo
-  : /* comment
-         comment
-     comment
-           comment
-    */ bar;
-
-test
-  ? foo
-  : /* comment
-         comment
-     comment
-           comment
-    */ test
-  ? foo
-  : /* comment
-  comment
-    comment
-   */ bar;
-
-test ? foo : /* comment */ bar;
-
-test
-  ? test /* c
-c */
-    ? foo
-    : bar
-  : bar;
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/decorators/classes.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/decorators/classes.js.snap
index 5596bdc59ae..2070b9a1129 100644
--- a/crates/rome_js_formatter/tests/specs/prettier/js/decorators/classes.js.snap
+++ b/crates/rome_js_formatter/tests/specs/prettier/js/decorators/classes.js.snap
@@ -1,5 +1,7 @@
 ---
 source: crates/rome_js_formatter/tests/prettier_tests.rs
+info:
+  test_file: js/decorators/classes.js
 ---
 
 # Input
@@ -28,7 +30,7 @@ const bar =
 ```diff
 --- Prettier
 +++ Rome
-@@ -1,24 +1,17 @@
+@@ -1,24 +1,16 @@
 -@deco
 -class Foo {}
 +@deco class Foo {}
@@ -59,7 +61,6 @@ const bar =
 -      //
 -    }
 -  );
-+
 +@deco
 +  class {
 +    //
@@ -81,7 +82,6 @@ const foo =
 }
 
 const bar =
-
 @deco
   class {
     //
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/decorators/comments.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/decorators/comments.js.snap
index 3e87de7b70c..c27bf38764d 100644
--- a/crates/rome_js_formatter/tests/specs/prettier/js/decorators/comments.js.snap
+++ b/crates/rome_js_formatter/tests/specs/prettier/js/decorators/comments.js.snap
@@ -1,5 +1,7 @@
 ---
 source: crates/rome_js_formatter/tests/prettier_tests.rs
+info:
+  test_file: js/decorators/comments.js
 ---
 
 # Input
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/decorators/multiple.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/decorators/multiple.js.snap
index 5933e4c9220..4398f1da5e6 100644
--- a/crates/rome_js_formatter/tests/specs/prettier/js/decorators/multiple.js.snap
+++ b/crates/rome_js_formatter/tests/specs/prettier/js/decorators/multiple.js.snap
@@ -1,5 +1,7 @@
 ---
 source: crates/rome_js_formatter/tests/prettier_tests.rs
+info:
+  test_file: js/decorators/multiple.js
 ---
 
 # Input
@@ -28,10 +30,9 @@ const foo = {
 ```diff
 --- Prettier
 +++ Rome
-@@ -1,18 +1,16 @@
+@@ -1,18 +1,15 @@
  const dog = {
 -  @readonly
-+
 +@readonly
    @nonenumerable
    @doubledValue
@@ -60,7 +61,6 @@ const foo = {
 
 ```js
 const dog = {
-
 @readonly
   @nonenumerable
   @doubledValue
@@ -115,6 +115,6 @@ error[SyntaxError]: expected a statement but instead found '}'
 
 # Lines exceeding max width of 80 characters
 ```
-   15: @multipleDecorators @inline @theyWontAllFitInOneline aVeryLongPropName: "A very long string as value";
+   14: @multipleDecorators @inline @theyWontAllFitInOneline aVeryLongPropName: "A very long string as value";
 ```
 
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/destructuring-ignore/ignore.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/destructuring-ignore/ignore.js.snap
deleted file mode 100644
index b33337d80fa..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/js/destructuring-ignore/ignore.js.snap
+++ /dev/null
@@ -1,126 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-const {
-  // prettier-ignore
-  bar =           1,
-} = foo
-
-const {
-  _,
-  // prettier-ignore
-  bar2 =           1,
-} = foo
-
-/* comments */
-const {
-  // prettier-ignore
-  bar3 =           1,         // comment
-} = foo
-
-const {
-  // prettier-ignore
-  bar4 =           1,         /* comment */
-} = foo
-
-const {
-  // prettier-ignore
-  bar5 =           /* comment */          1,
-} = foo
-
-/* RestElement */
-const {
-  // prettier-ignore
-  ...bar6
-} = foo
-
-// Nested
-const {
-  baz: {
-  // prettier-ignore
-  foo2 = [1, 2,    3]
-},
-  // prettier-ignore
-  bar7 =            1,
-} = foo
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -17,7 +17,7 @@
- 
- const {
-   // prettier-ignore
--  bar4 =           1 /* comment */,
-+  bar4 =           1, /* comment */
- } = foo;
- 
- const {
-@@ -35,7 +35,7 @@
- const {
-   baz: {
-     // prettier-ignore
--    foo2 = [1, 2,    3],
-+  foo2 = [1, 2,    3],
-   },
-   // prettier-ignore
-   bar7 =            1,
-```
-
-# Output
-
-```js
-const {
-  // prettier-ignore
-  bar =           1,
-} = foo;
-
-const {
-  _,
-  // prettier-ignore
-  bar2 =           1,
-} = foo;
-
-/* comments */
-const {
-  // prettier-ignore
-  bar3 =           1, // comment
-} = foo;
-
-const {
-  // prettier-ignore
-  bar4 =           1, /* comment */
-} = foo;
-
-const {
-  // prettier-ignore
-  bar5 =           /* comment */          1,
-} = foo;
-
-/* RestElement */
-const {
-  // prettier-ignore
-  ...bar6
-} = foo;
-
-// Nested
-const {
-  baz: {
-    // prettier-ignore
-  foo2 = [1, 2,    3],
-  },
-  // prettier-ignore
-  bar7 =            1,
-} = foo;
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/first-argument-expansion/test.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/first-argument-expansion/test.js.snap
index 6592cec2c55..6ce9f1ef7a1 100644
--- a/crates/rome_js_formatter/tests/specs/prettier/js/first-argument-expansion/test.js.snap
+++ b/crates/rome_js_formatter/tests/specs/prettier/js/first-argument-expansion/test.js.snap
@@ -1,5 +1,7 @@
 ---
 source: crates/rome_js_formatter/tests/prettier_tests.rs
+info:
+  test_file: js/first-argument-expansion/test.js
 ---
 
 # Input
@@ -232,23 +234,6 @@ func((args) => {
  
  compose(
    (a) => {
-@@ -146,12 +132,10 @@
-   500,
- );
- 
--setTimeout(
--  /* blip */ function () {
--    thing();
--  },
--  500,
--);
-+setTimeout(/* blip */
-+function () {
-+  thing();
-+}, 500);
- 
- func(
-   (args) => {
 ```
 
 # Output
@@ -388,10 +373,12 @@ setTimeout(
   500,
 );
 
-setTimeout(/* blip */
-function () {
-  thing();
-}, 500);
+setTimeout(
+  /* blip */ function () {
+    thing();
+  },
+  500,
+);
 
 func(
   (args) => {
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/for/comment.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/for/comment.js.snap
deleted file mode 100644
index fa499cfbfe6..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/js/for/comment.js.snap
+++ /dev/null
@@ -1,132 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-for (x
-/*a*/
-in //b
-y) //c
-;
-
-for (x in /*a*/ //b
-y); //c
-
-for (x /*a*/ in y); //b //c
-
-for (x
-//a
-in y);
-
-for(x in
-//a
-y);
-
-for (x
-/*a*/
-of //b
-y) //c
-;
-
-for (x of /*a*/ //b
-y); //c
-
-for (x /*a*/ of y); //b //c
-
-for (x
-//a
-of y);
-
-for(x of
-//a
-y);
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -1,25 +1,31 @@
-+for (x
- /*a*/
--for (x in y); //b //c
-+in y); //b //c
- 
--for (x /*a*/ in y); //b //c
-+for (x in /*a*/ y); //b //c
- 
- for (x /*a*/ in y); //b //c
- 
-+for (x
- //a
--for (x in y);
-+in y);
- 
-+for (x in
- //a
--for (x in y);
-+y);
- 
-+for (x
- /*a*/
--for (x of y); //b //c
-+of y); //b //c
- 
--for (x /*a*/ of y); //b //c
-+for (x of /*a*/ y); //b //c
- 
- for (x /*a*/ of y); //b //c
- 
-+for (x
- //a
--for (x of y);
-+of y);
- 
-+for (x of
- //a
--for (x of y);
-+y);
-```
-
-# Output
-
-```js
-for (x
-/*a*/
-in y); //b //c
-
-for (x in /*a*/ y); //b //c
-
-for (x /*a*/ in y); //b //c
-
-for (x
-//a
-in y);
-
-for (x in
-//a
-y);
-
-for (x
-/*a*/
-of y); //b //c
-
-for (x of /*a*/ y); //b //c
-
-for (x /*a*/ of y); //b //c
-
-for (x
-//a
-of y);
-
-for (x of
-//a
-y);
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/for/continue-and-break-comment-1.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/for/continue-and-break-comment-1.js.snap
index df8db1e75e8..652d589bbaa 100644
--- a/crates/rome_js_formatter/tests/specs/prettier/js/for/continue-and-break-comment-1.js.snap
+++ b/crates/rome_js_formatter/tests/specs/prettier/js/for/continue-and-break-comment-1.js.snap
@@ -1,5 +1,7 @@
 ---
 source: crates/rome_js_formatter/tests/prettier_tests.rs
+info:
+  test_file: js/for/continue-and-break-comment-1.js
 ---
 
 # Input
@@ -134,60 +136,18 @@ label2: {
 ```diff
 --- Prettier
 +++ Rome
-@@ -47,43 +47,43 @@
- }
- 
- for (;;) {
--  continue; /* comment */
-+  continue /* comment */;
- }
- 
- for (;;) {
--  break; /* comment */
-+  break /* comment */;
- }
- 
- for (const f of []) {
--  continue; /* comment */
-+  continue /* comment */;
- }
- 
- for (const f of []) {
--  break; /* comment */
-+  break /* comment */;
- }
- 
- for (const f in {}) {
--  continue; /* comment */
-+  continue /* comment */;
- }
- 
- for (const f in {}) {
--  break; /* comment */
-+  break /* comment */;
- }
+@@ -87,9 +87,9 @@
+ } while (true);
  
- while (true) {
--  continue; /* comment */
-+  continue /* comment */;
+ label1: for (;;) {
+-  continue label1 /* comment */;
++  continue label1; /* comment */
  }
  
- while (true) {
--  break; /* comment */
-+  break /* comment */;
+ label2: {
+-  break label2 /* comment */;
++  break label2; /* comment */
  }
- 
- do {
--  continue; /* comment */
-+  continue /* comment */;
- } while (true);
- 
- do {
--  break; /* comment */
-+  break /* comment */;
- } while (true);
- 
- label1: for (;;) {
 ```
 
 # Output
@@ -242,51 +202,51 @@ label2: {
 }
 
 for (;;) {
-  continue /* comment */;
+  continue; /* comment */
 }
 
 for (;;) {
-  break /* comment */;
+  break; /* comment */
 }
 
 for (const f of []) {
-  continue /* comment */;
+  continue; /* comment */
 }
 
 for (const f of []) {
-  break /* comment */;
+  break; /* comment */
 }
 
 for (const f in {}) {
-  continue /* comment */;
+  continue; /* comment */
 }
 
 for (const f in {}) {
-  break /* comment */;
+  break; /* comment */
 }
 
 while (true) {
-  continue /* comment */;
+  continue; /* comment */
 }
 
 while (true) {
-  break /* comment */;
+  break; /* comment */
 }
 
 do {
-  continue /* comment */;
+  continue; /* comment */
 } while (true);
 
 do {
-  break /* comment */;
+  break; /* comment */
 } while (true);
 
 label1: for (;;) {
-  continue label1 /* comment */;
+  continue label1; /* comment */
 }
 
 label2: {
-  break label2 /* comment */;
+  break label2; /* comment */
 }
 ```
 
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/for/continue-and-break-comment-2.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/for/continue-and-break-comment-2.js.snap
deleted file mode 100644
index 7a36ef2e95d..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/js/for/continue-and-break-comment-2.js.snap
+++ /dev/null
@@ -1,480 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-for(;;) {
-    continue
-    // comment
-    ;
-}
-
-for (;;) {
-    break
-    // comment
-    ;
-}
-
-for (const f of []) {
-    continue
-    // comment
-    ;
-}
-
-for (const f of []) {
-    break
-    // comment
-    ;
-}
-
-for (const f in {}) {
-    continue
-    // comment
-    ;
-}
-
-for (const f in {}) {
-    break
-    // comment
-    ;
-}
-
-while(true) {
-    continue
-    // comment
-    ;
-}
-
-while (true) {
-    break
-    // comment
-    ;
-}
-
-do {
-    continue
-    // comment
-    ;
-} while(true);
-
-
-do {
-    break
-    // comment
-    ;
-} while(true);
-
-label1: for (;;) {
-    continue label1
-    // comment
-    ;
-}
-
-label2: {
-    break label2
-    // comment
-    ;
-};
-
-for(;;) {
-    continue
-    /* comment */
-    ;
-}
-
-for (;;) {
-    break
-    /* comment */
-    ;
-}
-
-for (const f of []) {
-    continue
-    /* comment */
-    ;
-}
-
-for (const f of []) {
-    break
-    /* comment */
-    ;
-}
-
-for (const f in {}) {
-    continue
-    /* comment */
-    ;
-}
-
-for (const f in {}) {
-    break
-    /* comment */
-    ;
-}
-
-while(true) {
-    continue
-    /* comment */
-    ;
-}
-
-while (true) {
-    break
-    /* comment */
-    ;
-}
-
-do {
-    continue
-    /* comment */
-    ;
-} while(true);
-
-
-do {
-    break
-    /* comment */
-    ;
-} while(true);
-
-label1: for (;;) {
-    continue label1
-    /* comment */
-    ;
-}
-
-label2: {
-    break label2
-    /* comment */
-    ;
-};
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -1,119 +1,143 @@
- for (;;) {
--  continue;
-+  continue
-   // comment
-+  ;
- }
- 
- for (;;) {
--  break;
-+  break
-   // comment
-+  ;
- }
- 
- for (const f of []) {
--  continue;
-+  continue
-   // comment
-+  ;
- }
- 
- for (const f of []) {
--  break;
-+  break
-   // comment
-+  ;
- }
- 
- for (const f in {}) {
--  continue;
-+  continue
-   // comment
-+  ;
- }
- 
- for (const f in {}) {
--  break;
-+  break
-   // comment
-+  ;
- }
- 
- while (true) {
--  continue;
-+  continue
-   // comment
-+  ;
- }
- 
- while (true) {
--  break;
-+  break
-   // comment
-+  ;
- }
- 
- do {
--  continue;
-+  continue
-   // comment
-+  ;
- } while (true);
- 
- do {
--  break;
-+  break
-   // comment
-+  ;
- } while (true);
- 
- label1: for (;;) {
--  continue label1;
-+  continue label1
-   // comment
-+  ;
- }
- 
- label2: {
--  break label2;
-+  break label2
-   // comment
-+  ;
- }
- 
- for (;;) {
--  continue;
-+  continue
-   /* comment */
-+  ;
- }
- 
- for (;;) {
--  break;
-+  break
-   /* comment */
-+  ;
- }
- 
- for (const f of []) {
--  continue;
-+  continue
-   /* comment */
-+  ;
- }
- 
- for (const f of []) {
--  break;
-+  break
-   /* comment */
-+  ;
- }
- 
- for (const f in {}) {
--  continue;
-+  continue
-   /* comment */
-+  ;
- }
- 
- for (const f in {}) {
--  break;
-+  break
-   /* comment */
-+  ;
- }
- 
- while (true) {
--  continue;
-+  continue
-   /* comment */
-+  ;
- }
- 
- while (true) {
--  break;
-+  break
-   /* comment */
-+  ;
- }
- 
- do {
--  continue;
-+  continue
-   /* comment */
-+  ;
- } while (true);
- 
- do {
--  break;
-+  break
-   /* comment */
-+  ;
- } while (true);
- 
- label1: for (;;) {
--  continue label1;
-+  continue label1
-   /* comment */
-+  ;
- }
- 
- label2: {
--  break label2;
-+  break label2
-   /* comment */
-+  ;
- }
-```
-
-# Output
-
-```js
-for (;;) {
-  continue
-  // comment
-  ;
-}
-
-for (;;) {
-  break
-  // comment
-  ;
-}
-
-for (const f of []) {
-  continue
-  // comment
-  ;
-}
-
-for (const f of []) {
-  break
-  // comment
-  ;
-}
-
-for (const f in {}) {
-  continue
-  // comment
-  ;
-}
-
-for (const f in {}) {
-  break
-  // comment
-  ;
-}
-
-while (true) {
-  continue
-  // comment
-  ;
-}
-
-while (true) {
-  break
-  // comment
-  ;
-}
-
-do {
-  continue
-  // comment
-  ;
-} while (true);
-
-do {
-  break
-  // comment
-  ;
-} while (true);
-
-label1: for (;;) {
-  continue label1
-  // comment
-  ;
-}
-
-label2: {
-  break label2
-  // comment
-  ;
-}
-
-for (;;) {
-  continue
-  /* comment */
-  ;
-}
-
-for (;;) {
-  break
-  /* comment */
-  ;
-}
-
-for (const f of []) {
-  continue
-  /* comment */
-  ;
-}
-
-for (const f of []) {
-  break
-  /* comment */
-  ;
-}
-
-for (const f in {}) {
-  continue
-  /* comment */
-  ;
-}
-
-for (const f in {}) {
-  break
-  /* comment */
-  ;
-}
-
-while (true) {
-  continue
-  /* comment */
-  ;
-}
-
-while (true) {
-  break
-  /* comment */
-  ;
-}
-
-do {
-  continue
-  /* comment */
-  ;
-} while (true);
-
-do {
-  break
-  /* comment */
-  ;
-} while (true);
-
-label1: for (;;) {
-  continue label1
-  /* comment */
-  ;
-}
-
-label2: {
-  break label2
-  /* comment */
-  ;
-}
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/for/continue-and-break-comment-without-blocks.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/for/continue-and-break-comment-without-blocks.js.snap
index fea0e14b6e2..348226647d0 100644
--- a/crates/rome_js_formatter/tests/specs/prettier/js/for/continue-and-break-comment-without-blocks.js.snap
+++ b/crates/rome_js_formatter/tests/specs/prettier/js/for/continue-and-break-comment-without-blocks.js.snap
@@ -1,5 +1,7 @@
 ---
 source: crates/rome_js_formatter/tests/prettier_tests.rs
+info:
+  test_file: js/for/continue-and-break-comment-without-blocks.js
 ---
 
 # Input
@@ -110,261 +112,89 @@ label1: for (;;) continue label1
 ```diff
 --- Prettier
 +++ Rome
-@@ -1,69 +1,104 @@
--for (;;) continue;
--// comment
-+for (;;)
-+  continue
-+  // comment
-+  ;
+@@ -58,7 +58,7 @@
+ for (const f in {}) break;
+ /* comment */
  
--for (;;) break;
--// comment
-+for (;;)
-+  break
-+  // comment
-+  ;
+-label1: for (;;) continue label1 /* comment */;
++label1: for (;;) continue label1; /* comment */
  
--for (const f of []) continue;
--// comment
-+for (const f of [])
-+  continue
-+  // comment
-+  ;
- 
--for (const f of []) break;
--// comment
-+for (const f of [])
-+  break
-+  // comment
-+  ;
- 
--for (const f in {}) continue;
--// comment
-+for (const f in {})
-+  continue
-+  // comment
-+  ;
- 
--for (const f in {}) break;
--// comment
-+for (const f in {})
-+  break
-+  // comment
-+  ;
- 
--for (;;) continue; // comment
-+for (;;)
-+  continue; // comment
- 
--for (;;) break; // comment
-+for (;;)
-+  break; // comment
- 
--for (const f of []) continue; // comment
-+for (const f of [])
-+  continue; // comment
- 
--for (const f of []) break; // comment
-+for (const f of [])
-+  break; // comment
- 
--for (const f in {}) continue; // comment
-+for (const f in {})
-+  continue; // comment
- 
--for (const f in {}) break; // comment
-+for (const f in {})
-+  break; // comment
- 
--for (;;) continue; /* comment */
-+for (;;) continue /* comment */;
- 
--for (;;) break; /* comment */
-+for (;;) break /* comment */;
- 
--for (const f of []) continue; /* comment */
-+for (const f of []) continue /* comment */;
- 
--for (const f of []) break; /* comment */
-+for (const f of []) break /* comment */;
- 
--for (const f in {}) continue; /* comment */
-+for (const f in {}) continue /* comment */;
- 
--for (const f in {}) break; /* comment */
-+for (const f in {}) break /* comment */;
- 
--for (;;) continue;
--/* comment */
-+for (;;)
-+  continue
-+  /* comment */
-+  ;
- 
--for (;;) break;
--/* comment */
-+for (;;)
-+  break
-+  /* comment */
-+  ;
- 
--for (const f of []) continue;
--/* comment */
-+for (const f of [])
-+  continue
-+  /* comment */
-+  ;
- 
--for (const f of []) break;
--/* comment */
-+for (const f of [])
-+  break
-+  /* comment */
-+  ;
- 
--for (const f in {}) continue;
--/* comment */
-+for (const f in {})
-+  continue
-+  /* comment */
-+  ;
- 
--for (const f in {}) break;
--/* comment */
-+for (const f in {})
-+  break
-+  /* comment */
-+  ;
- 
- label1: for (;;) continue label1 /* comment */;
- 
--label1: for (;;) continue label1;
--/* comment */
-+label1: for (;;)
-+  continue label1
-+  /* comment */
-+  ;
- 
--label1: for (;;) continue label1; // comment
-+label1: for (;;)
-+  continue label1; // comment
- 
--label1: for (;;) continue label1;
--// comment
-+label1: for (;;)
-+  continue label1
-+  // comment
-+  ;
+ label1: for (;;) continue label1;
+ /* comment */
 ```
 
 # Output
 
 ```js
-for (;;)
-  continue
-  // comment
-  ;
+for (;;) continue;
+// comment
 
-for (;;)
-  break
-  // comment
-  ;
+for (;;) break;
+// comment
 
-for (const f of [])
-  continue
-  // comment
-  ;
+for (const f of []) continue;
+// comment
 
-for (const f of [])
-  break
-  // comment
-  ;
+for (const f of []) break;
+// comment
 
-for (const f in {})
-  continue
-  // comment
-  ;
+for (const f in {}) continue;
+// comment
 
-for (const f in {})
-  break
-  // comment
-  ;
+for (const f in {}) break;
+// comment
 
-for (;;)
-  continue; // comment
+for (;;) continue; // comment
 
-for (;;)
-  break; // comment
+for (;;) break; // comment
 
-for (const f of [])
-  continue; // comment
+for (const f of []) continue; // comment
 
-for (const f of [])
-  break; // comment
+for (const f of []) break; // comment
 
-for (const f in {})
-  continue; // comment
+for (const f in {}) continue; // comment
 
-for (const f in {})
-  break; // comment
+for (const f in {}) break; // comment
 
-for (;;) continue /* comment */;
+for (;;) continue; /* comment */
 
-for (;;) break /* comment */;
+for (;;) break; /* comment */
 
-for (const f of []) continue /* comment */;
+for (const f of []) continue; /* comment */
 
-for (const f of []) break /* comment */;
+for (const f of []) break; /* comment */
 
-for (const f in {}) continue /* comment */;
+for (const f in {}) continue; /* comment */
 
-for (const f in {}) break /* comment */;
+for (const f in {}) break; /* comment */
 
-for (;;)
-  continue
-  /* comment */
-  ;
+for (;;) continue;
+/* comment */
 
-for (;;)
-  break
-  /* comment */
-  ;
+for (;;) break;
+/* comment */
 
-for (const f of [])
-  continue
-  /* comment */
-  ;
+for (const f of []) continue;
+/* comment */
 
-for (const f of [])
-  break
-  /* comment */
-  ;
+for (const f of []) break;
+/* comment */
 
-for (const f in {})
-  continue
-  /* comment */
-  ;
+for (const f in {}) continue;
+/* comment */
 
-for (const f in {})
-  break
-  /* comment */
-  ;
+for (const f in {}) break;
+/* comment */
 
-label1: for (;;) continue label1 /* comment */;
+label1: for (;;) continue label1; /* comment */
 
-label1: for (;;)
-  continue label1
-  /* comment */
-  ;
+label1: for (;;) continue label1;
+/* comment */
 
-label1: for (;;)
-  continue label1; // comment
+label1: for (;;) continue label1; // comment
 
-label1: for (;;)
-  continue label1
-  // comment
-  ;
+label1: for (;;) continue label1;
+// comment
 ```
 
 
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/function-first-param/function_expression.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/function-first-param/function_expression.js.snap
deleted file mode 100644
index ec1834e469a..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/js/function-first-param/function_expression.js.snap
+++ /dev/null
@@ -1,141 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-//https://github.com/prettier/prettier/issues/3002
-beep.boop().baz("foo",
-{
-  some: {
-    thing: {
-      nested: true
-    }
-  }
-},
-{ another: { thing: true } },
-() => {});
-
-
-//https://github.com/prettier/prettier/issues/2984
-db.collection('indexOptionDefault').createIndex({ a: 1 }, {
-  indexOptionDefaults: true,
-  w: 2,
-  wtimeout: 1000
-}, function(err) {
-  test.equal(null, err);
-  test.deepEqual({ w: 2, wtimeout: 1000 }, commandResult.writeConcern);
-
-  client.close();
-  done();
-});```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -1,30 +1,34 @@
- //https://github.com/prettier/prettier/issues/3002
--beep.boop().baz(
--  "foo",
--  {
--    some: {
--      thing: {
--        nested: true,
-+beep
-+  .boop()
-+  .baz(
-+    "foo",
-+    {
-+      some: {
-+        thing: {
-+          nested: true,
-+        },
-       },
-     },
--  },
--  { another: { thing: true } },
--  () => {},
--);
-+    { another: { thing: true } },
-+    () => {},
-+  );
- 
- //https://github.com/prettier/prettier/issues/2984
--db.collection("indexOptionDefault").createIndex(
--  { a: 1 },
--  {
--    indexOptionDefaults: true,
--    w: 2,
--    wtimeout: 1000,
--  },
--  function (err) {
--    test.equal(null, err);
--    test.deepEqual({ w: 2, wtimeout: 1000 }, commandResult.writeConcern);
-+db
-+  .collection("indexOptionDefault")
-+  .createIndex(
-+    { a: 1 },
-+    {
-+      indexOptionDefaults: true,
-+      w: 2,
-+      wtimeout: 1000,
-+    },
-+    function (err) {
-+      test.equal(null, err);
-+      test.deepEqual({ w: 2, wtimeout: 1000 }, commandResult.writeConcern);
- 
--    client.close();
--    done();
--  },
--);
-+      client.close();
-+      done();
-+    },
-+  );
-```
-
-# Output
-
-```js
-//https://github.com/prettier/prettier/issues/3002
-beep
-  .boop()
-  .baz(
-    "foo",
-    {
-      some: {
-        thing: {
-          nested: true,
-        },
-      },
-    },
-    { another: { thing: true } },
-    () => {},
-  );
-
-//https://github.com/prettier/prettier/issues/2984
-db
-  .collection("indexOptionDefault")
-  .createIndex(
-    { a: 1 },
-    {
-      indexOptionDefaults: true,
-      w: 2,
-      wtimeout: 1000,
-    },
-    function (err) {
-      test.equal(null, err);
-      test.deepEqual({ w: 2, wtimeout: 1000 }, commandResult.writeConcern);
-
-      client.close();
-      done();
-    },
-  );
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/if/expr_and_same_line_comments.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/if/expr_and_same_line_comments.js.snap
deleted file mode 100644
index f2d66d0228e..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/js/if/expr_and_same_line_comments.js.snap
+++ /dev/null
@@ -1,104 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-if (a === 0) doSomething(); // comment A1
-else if (a === 1) doSomethingElse(); // comment B1
-else if (a === 2) doSomethingElse(); // comment C1
-
-if (a === 0) doSomething(); /* comment A2 */
-else if (a === 1) doSomethingElse(); /* comment B2 */
-else if (a === 2) doSomethingElse(); /* comment C2 */
-
-if (a === 0) expr; // comment A3
-else if (a === 1) expr; // comment B3
-else if (a === 2) expr; // comment C3
-
-if (a === 0) expr; /* comment A4 */
-else if (a === 1) expr; /* comment B4 */
-else if (a === 2) expr; /* comment C4 */
-
-if (a === 0) looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong; // comment A5
-else if (a === 1) looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong; // comment B5
-else if (a === 2) looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong; // comment C5
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -1,14 +1,20 @@
--if (a === 0) doSomething(); // comment A1
--else if (a === 1) doSomethingElse(); // comment B1
--else if (a === 2) doSomethingElse(); // comment C1
-+if (a === 0)
-+  doSomething(); // comment A1
-+else if (a === 1)
-+  doSomethingElse(); // comment B1
-+else if (a === 2)
-+  doSomethingElse(); // comment C1
- 
- if (a === 0) doSomething(); /* comment A2 */
- else if (a === 1) doSomethingElse(); /* comment B2 */
- else if (a === 2) doSomethingElse(); /* comment C2 */
- 
--if (a === 0) expr; // comment A3
--else if (a === 1) expr; // comment B3
--else if (a === 2) expr; // comment C3
-+if (a === 0)
-+  expr; // comment A3
-+else if (a === 1)
-+  expr; // comment B3
-+else if (a === 2)
-+  expr; // comment C3
- 
- if (a === 0) expr; /* comment A4 */
- else if (a === 1) expr; /* comment B4 */
-```
-
-# Output
-
-```js
-if (a === 0)
-  doSomething(); // comment A1
-else if (a === 1)
-  doSomethingElse(); // comment B1
-else if (a === 2)
-  doSomethingElse(); // comment C1
-
-if (a === 0) doSomething(); /* comment A2 */
-else if (a === 1) doSomethingElse(); /* comment B2 */
-else if (a === 2) doSomethingElse(); /* comment C2 */
-
-if (a === 0)
-  expr; // comment A3
-else if (a === 1)
-  expr; // comment B3
-else if (a === 2)
-  expr; // comment C3
-
-if (a === 0) expr; /* comment A4 */
-else if (a === 1) expr; /* comment B4 */
-else if (a === 2) expr; /* comment C4 */
-
-if (a === 0)
-  looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong; // comment A5
-else if (a === 1)
-  looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong; // comment B5
-else if (a === 2)
-  looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong; // comment C5
-```
-
-
-# Lines exceeding max width of 80 characters
-```
-   24:   looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong; // comment A5
-   26:   looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong; // comment B5
-   28:   looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong; // comment C5
-```
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/if/if_comments.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/if/if_comments.js.snap
deleted file mode 100644
index ce9dac60a1e..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/js/if/if_comments.js.snap
+++ /dev/null
@@ -1,191 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-async function f1() {
-  if (untrackedChoice === 0) /* Cancel */ {
-    return null;
-  } else if (untrackedChoice === 1) /* Add */ {
-    await repository.addAll(Array.from(untrackedChanges.keys()));
-    shouldAmend = true;
-  } else if (untrackedChoice === 2) /* Allow Untracked */ {
-    allowUntracked = true;
-  }
-}
-
-async function f2() {
-  if (untrackedChoice === 0) /* Cancel */
-    null;
-  else if (untrackedChoice === 1) /* Add */
-    shouldAmend = true;
-  else if (untrackedChoice === 2) /* Allow Untracked */
-    allowUntracked = true;
-}
-
-async function f3() {
-  if (untrackedChoice === 0) /* Cancel */ // Cancel
-    null;
-  else if (untrackedChoice === 1) /* Add */ // Add
-    shouldAmend = true;
-  else if (untrackedChoice === 2) /* Allow Untracked */ // Allow Untracked
-    allowUntracked = true;
-}
-
-async function f4() {
-  if (untrackedChoice === 0)
-    /* Cancel */ {
-      return null;
-    }
-  else if (untrackedChoice === 1)
-    /* Add */ {
-      await repository.addAll(Array.from(untrackedChanges.keys()));
-      shouldAmend = true;
-    }
-  else if (untrackedChoice === 2)
-    /* Allow Untracked */ {
-      allowUntracked = true;
-    }
-}
-
-async function f5() {
-  if (untrackedChoice === 0) {
-    /* Cancel */ return null;
-  } else if (untrackedChoice === 1) {
-    /* Add */ await repository.addAll(Array.from(untrackedChanges.keys()));
-    shouldAmend = true;
-  } else if (untrackedChoice === 2) {
-    /* Allow Untracked */ allowUntracked = true;
-  }
-}
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -1,11 +1,11 @@
- async function f1() {
--  if (untrackedChoice === 0) {
--    /* Cancel */ return null;
--  } else if (untrackedChoice === 1) {
--    /* Add */ await repository.addAll(Array.from(untrackedChanges.keys()));
-+  if (untrackedChoice === 0) /* Cancel */ {
-+    return null;
-+  } else if (untrackedChoice === 1) /* Add */ {
-+    await repository.addAll(Array.from(untrackedChanges.keys()));
-     shouldAmend = true;
--  } else if (untrackedChoice === 2) {
--    /* Allow Untracked */ allowUntracked = true;
-+  } else if (untrackedChoice === 2) /* Allow Untracked */ {
-+    allowUntracked = true;
-   }
- }
- 
-@@ -16,25 +16,28 @@
- }
- 
- async function f3() {
--  if (untrackedChoice === 0)
--    /* Cancel */ // Cancel
-+  if (untrackedChoice === 0) /* Cancel */
-+    // Cancel
-     null;
--  else if (untrackedChoice === 1)
--    /* Add */ // Add
-+  else if (untrackedChoice === 1) /* Add */
-+    // Add
-     shouldAmend = true;
--  else if (untrackedChoice === 2)
--    /* Allow Untracked */ // Allow Untracked
-+  else if (untrackedChoice === 2) /* Allow Untracked */
-+    // Allow Untracked
-     allowUntracked = true;
- }
- 
- async function f4() {
--  if (untrackedChoice === 0) {
--    /* Cancel */ return null;
--  } else if (untrackedChoice === 1) {
--    /* Add */ await repository.addAll(Array.from(untrackedChanges.keys()));
-+  if (untrackedChoice === 0)
-+  /* Cancel */ {
-+    return null;
-+  } else if (untrackedChoice === 1)
-+  /* Add */ {
-+    await repository.addAll(Array.from(untrackedChanges.keys()));
-     shouldAmend = true;
--  } else if (untrackedChoice === 2) {
--    /* Allow Untracked */ allowUntracked = true;
-+  } else if (untrackedChoice === 2)
-+  /* Allow Untracked */ {
-+    allowUntracked = true;
-   }
- }
- 
-```
-
-# Output
-
-```js
-async function f1() {
-  if (untrackedChoice === 0) /* Cancel */ {
-    return null;
-  } else if (untrackedChoice === 1) /* Add */ {
-    await repository.addAll(Array.from(untrackedChanges.keys()));
-    shouldAmend = true;
-  } else if (untrackedChoice === 2) /* Allow Untracked */ {
-    allowUntracked = true;
-  }
-}
-
-async function f2() {
-  if (untrackedChoice === 0) /* Cancel */ null;
-  else if (untrackedChoice === 1) /* Add */ shouldAmend = true;
-  else if (untrackedChoice === 2) /* Allow Untracked */ allowUntracked = true;
-}
-
-async function f3() {
-  if (untrackedChoice === 0) /* Cancel */
-    // Cancel
-    null;
-  else if (untrackedChoice === 1) /* Add */
-    // Add
-    shouldAmend = true;
-  else if (untrackedChoice === 2) /* Allow Untracked */
-    // Allow Untracked
-    allowUntracked = true;
-}
-
-async function f4() {
-  if (untrackedChoice === 0)
-  /* Cancel */ {
-    return null;
-  } else if (untrackedChoice === 1)
-  /* Add */ {
-    await repository.addAll(Array.from(untrackedChanges.keys()));
-    shouldAmend = true;
-  } else if (untrackedChoice === 2)
-  /* Allow Untracked */ {
-    allowUntracked = true;
-  }
-}
-
-async function f5() {
-  if (untrackedChoice === 0) {
-    /* Cancel */ return null;
-  } else if (untrackedChoice === 1) {
-    /* Add */ await repository.addAll(Array.from(untrackedChanges.keys()));
-    shouldAmend = true;
-  } else if (untrackedChoice === 2) {
-    /* Allow Untracked */ allowUntracked = true;
-  }
-}
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/if/trailing_comment.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/if/trailing_comment.js.snap
deleted file mode 100644
index 1ff518ef544..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/js/if/trailing_comment.js.snap
+++ /dev/null
@@ -1,65 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
-info:
-  test_file: js/if/trailing_comment.js
----
-
-# Input
-
-```js
-if (code === 92 /* '\' */) {}
-if (code === 92 /* '\' */ /* '\' */) {}
-
-if (code === 92) /* '\' */ {}
-if (code === 92) { /* '\' */ }
-
-if (
-  1
-  // Comment
-) {
-  a;
-}
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -3,8 +3,7 @@
- if (code === 92 /* '\' */ /* '\' */) {
- }
- 
--if (code === 92) {
--  /* '\' */
-+if (code === 92) /* '\' */ {
- }
- if (code === 92) {
-   /* '\' */
-```
-
-# Output
-
-```js
-if (code === 92 /* '\' */) {
-}
-if (code === 92 /* '\' */ /* '\' */) {
-}
-
-if (code === 92) /* '\' */ {
-}
-if (code === 92) {
-  /* '\' */
-}
-
-if (
-  1
-  // Comment
-) {
-  a;
-}
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/ignore/ignore-2.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/ignore/ignore-2.js.snap
deleted file mode 100644
index db897c594ef..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/js/ignore/ignore-2.js.snap
+++ /dev/null
@@ -1,73 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-// #8736
-
-function HelloWorld() {
-  return (
-    <div
-      {...{} /*
-      // @ts-ignore */ /* prettier-ignore */}
-      invalidProp="HelloWorld"
-    >
-      test
-    </div>
-  );
-}
-
-a = <div {.../* prettier-ignore */b}/>
-a = <div {...b/* prettier-ignore */}/>
-a = <div {.../* prettier-ignore */{}}/>
-a = <div {...{/* prettier-ignore */}}/>
-a = <div {...{}/* prettier-ignore */}/>
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -12,8 +12,8 @@
-   );
- }
- 
--a = <div {.../* prettier-ignore */ b} />;
-+a = <div {... /* prettier-ignore */ b} />;
- a = <div {...b /* prettier-ignore */} />;
--a = <div {.../* prettier-ignore */ {}} />;
-+a = <div {... /* prettier-ignore */ {}} />;
- a = <div {...{/* prettier-ignore */}} />;
- a = <div {...{} /* prettier-ignore */} />;
-```
-
-# Output
-
-```js
-// #8736
-
-function HelloWorld() {
-  return (
-    <div
-      {...{} /*
-      // @ts-ignore */ /* prettier-ignore */}
-      invalidProp="HelloWorld"
-    >
-      test
-    </div>
-  );
-}
-
-a = <div {... /* prettier-ignore */ b} />;
-a = <div {...b /* prettier-ignore */} />;
-a = <div {... /* prettier-ignore */ {}} />;
-a = <div {...{/* prettier-ignore */}} />;
-a = <div {...{} /* prettier-ignore */} />;
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/ignore/ignore.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/ignore/ignore.js.snap
deleted file mode 100644
index 2836bc1b43e..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/js/ignore/ignore.js.snap
+++ /dev/null
@@ -1,149 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-function a() {
-  // prettier-ignore
-  var fnString =
-    '"' + this.USE + ' ' + this.STRICT + '";\n' +
-    this.filterPrefix() +
-    'var fn=' + this.generateFunction('fn', 's,l,a,i') +
-    extra +
-    this.watchFns() +
-    'return fn;';
-
-  // prettier-ignore
-  const identity = Matrix.create(
-    1, 0, 0,
-    0, 1, 0,
-    0, 0, 0
-  );
-
-  // Let's make sure that this comment doesn't interfere
-
-  // prettier-ignore
-  const commentsWithPrettierIgnore =   {
-    "ewww":
-            "gross-formatting",
-  };
-
-  function giveMeSome() {
-    a(  a  ); // prettier-ignore
-    // shouldn't I return something?  :shrug:
-  }
-
-  // prettier-ignore
-  console.error(
-    'In order to use ' + prompt + ', you need to configure a ' +
-    'few environment variables to be able to commit to the ' +
-    'repository. Follow those steps to get you setup:\n' +
-    '\n' +
-    'Go to https://github.com/settings/tokens/new\n' +
-    ' - Fill "Token description" with "' + prompt + ' for ' +
-      repoSlug + '"\n' +
-    ' - Check "public_repo"\n' +
-    ' - Press "Generate Token"\n' +
-    '\n' +
-    'In a different tab, go to https://travis-ci.org/' +
-      repoSlug + '/settings\n' +
-    ' - Make sure "Build only if .travis.yml is present" is ON\n' +
-    ' - Fill "Name" with "GITHUB_USER" and "Value" with the name of the ' +
-      'account you generated the token with. Press "Add"\n' +
-    '\n' +
-    'Once this is done, commit anything to the repository to restart ' +
-      'Travis and it should work :)'
-  );
-}
-
-const response = {
-  // prettier-ignore
-  '_text': 'Turn on the lights',
-  intent: 'lights',
-};
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -24,7 +24,7 @@
-   };
- 
-   function giveMeSome() {
--    a(  a  ); // prettier-ignore
-+    a(a); // prettier-ignore
-     // shouldn't I return something?  :shrug:
-   }
- 
-```
-
-# Output
-
-```js
-function a() {
-  // prettier-ignore
-  var fnString =
-    '"' + this.USE + ' ' + this.STRICT + '";\n' +
-    this.filterPrefix() +
-    'var fn=' + this.generateFunction('fn', 's,l,a,i') +
-    extra +
-    this.watchFns() +
-    'return fn;';
-
-  // prettier-ignore
-  const identity = Matrix.create(
-    1, 0, 0,
-    0, 1, 0,
-    0, 0, 0
-  );
-
-  // Let's make sure that this comment doesn't interfere
-
-  // prettier-ignore
-  const commentsWithPrettierIgnore =   {
-    "ewww":
-            "gross-formatting",
-  };
-
-  function giveMeSome() {
-    a(a); // prettier-ignore
-    // shouldn't I return something?  :shrug:
-  }
-
-  // prettier-ignore
-  console.error(
-    'In order to use ' + prompt + ', you need to configure a ' +
-    'few environment variables to be able to commit to the ' +
-    'repository. Follow those steps to get you setup:\n' +
-    '\n' +
-    'Go to https://github.com/settings/tokens/new\n' +
-    ' - Fill "Token description" with "' + prompt + ' for ' +
-      repoSlug + '"\n' +
-    ' - Check "public_repo"\n' +
-    ' - Press "Generate Token"\n' +
-    '\n' +
-    'In a different tab, go to https://travis-ci.org/' +
-      repoSlug + '/settings\n' +
-    ' - Make sure "Build only if .travis.yml is present" is ON\n' +
-    ' - Fill "Name" with "GITHUB_USER" and "Value" with the name of the ' +
-      'account you generated the token with. Press "Add"\n' +
-    '\n' +
-    'Once this is done, commit anything to the repository to restart ' +
-      'Travis and it should work :)'
-  );
-}
-
-const response = {
-  // prettier-ignore
-  '_text': 'Turn on the lights',
-  intent: "lights",
-};
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/ignore/issue-10661.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/ignore/issue-10661.js.snap
deleted file mode 100644
index fe735d26282..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/js/ignore/issue-10661.js.snap
+++ /dev/null
@@ -1,107 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-verylongidentifierthatwillwrap123123123123123(
-  a.b
-    // prettier-ignore
-    // Some other comment here
-    .c
-);
-
-call(
-  // comment
-  a.
-    // prettier-ignore
-    b
-)
-
-call(
-  a(
-/*
-this won't get formatted too,
-because the prettier-ignore comment is attached as MemberExpression leading comment
-*/
-1,
-2.0000, 3
-)
-    // prettier-ignore
-    .c
-)
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -8,19 +8,20 @@
- call(
-   // comment
-   a.
--    // prettier-ignore
-+  // prettier-ignore
-     b,
- );
- 
- call(
-   a(
--/*
-+    /*
- this won't get formatted too,
- because the prettier-ignore comment is attached as MemberExpression leading comment
- */
--1,
--2.0000, 3
--)
-+    1,
-+    2.0000,
-+    3,
-+  )
-     // prettier-ignore
-     .c,
- );
-```
-
-# Output
-
-```js
-verylongidentifierthatwillwrap123123123123123(
-  a.b
-    // prettier-ignore
-    // Some other comment here
-    .c,
-);
-
-call(
-  // comment
-  a.
-  // prettier-ignore
-    b,
-);
-
-call(
-  a(
-    /*
-this won't get formatted too,
-because the prettier-ignore comment is attached as MemberExpression leading comment
-*/
-    1,
-    2.0000,
-    3,
-  )
-    // prettier-ignore
-    .c,
-);
-```
-
-
-# Lines exceeding max width of 80 characters
-```
-   19: because the prettier-ignore comment is attached as MemberExpression leading comment
-```
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/ignore/semi/directive.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/ignore/semi/directive.js.snap
deleted file mode 100644
index 1fe329de739..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/js/ignore/semi/directive.js.snap
+++ /dev/null
@@ -1,50 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-// prettier-ignore
-'use strict';
-[].forEach();
-
-function foo() {
-// prettier-ignore
-'use strict';
-[].forEach();
-}
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -4,6 +4,6 @@
- 
- function foo() {
-   // prettier-ignore
--  'use strict';
-+'use strict';
-   [].forEach();
- }
-```
-
-# Output
-
-```js
-// prettier-ignore
-'use strict';
-[].forEach();
-
-function foo() {
-  // prettier-ignore
-'use strict';
-  [].forEach();
-}
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/import/comments.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/import/comments.js.snap
deleted file mode 100644
index f1306008ae0..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/js/import/comments.js.snap
+++ /dev/null
@@ -1,149 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-import { a //comment1
-//comment2
-//comment3
-as b} from "";
-
-import {
-  a as //comment1
-  //comment2
-  //comment3
-  b1
-} from "";
-
-import {
-  a as //comment2 //comment1
-  //comment3
-  b2
-} from "";
-
-import {
-  a as //comment3 //comment2 //comment1
-  b3
-} from "";
-
-import {
-  // comment 1
-  FN1, // comment 2
-  /* comment 3 */ FN2,
-  // FN3,
-  FN4 /* comment 4 */
-  // FN4,
-  // FN5
-} from "./module";
-
-import {
-  ExecutionResult,
-  DocumentNode,
-  /* tslint:disable */
-  SelectionSetNode,
-  /* tslint:enable */
-} from 'graphql';
-
-import x, {
-  // comment
-  y
-} from 'z';
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -1,26 +1,25 @@
- import {
--  //comment1
-+  a //comment1
-   //comment2
-   //comment3
--  a as b,
-+  as b,
- } from "";
- 
- import {
--  //comment1
-+  a as //comment1
-   //comment2
-   //comment3
--  a as b1,
-+  b1,
- } from "";
- 
- import {
--  //comment2 //comment1
-+  a as //comment2 //comment1
-   //comment3
--  a as b2,
-+  b2,
- } from "";
- 
- import {
--  //comment3 //comment2 //comment1
--  a as b3,
-+  a as b3, //comment3 //comment2 //comment1
- } from "";
- 
- import {
-```
-
-# Output
-
-```js
-import {
-  a //comment1
-  //comment2
-  //comment3
-  as b,
-} from "";
-
-import {
-  a as //comment1
-  //comment2
-  //comment3
-  b1,
-} from "";
-
-import {
-  a as //comment2 //comment1
-  //comment3
-  b2,
-} from "";
-
-import {
-  a as b3, //comment3 //comment2 //comment1
-} from "";
-
-import {
-  // comment 1
-  FN1, // comment 2
-  /* comment 3 */ FN2,
-  // FN3,
-  FN4 /* comment 4 */,
-  // FN4,
-  // FN5
-} from "./module";
-
-import {
-  ExecutionResult,
-  DocumentNode,
-  /* tslint:disable */
-  SelectionSetNode,
-  /* tslint:enable */
-} from "graphql";
-
-import x, {
-  // comment
-  y,
-} from "z";
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/label/comment.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/label/comment.js.snap
deleted file mode 100644
index 8cb24c64bf1..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/js/label/comment.js.snap
+++ /dev/null
@@ -1,53 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-{
-  inf_leave: // goto emulation
-  for (;;) {}
-}
-{
-  inf_leave:
-  // goto emulation
-  for (; ;) { }
-}
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -1,8 +1,8 @@
- {
--  // goto emulation
--  inf_leave: for (;;) {}
-+  inf_leave: for (;;) {} // goto emulation
- }
- {
-+  inf_leave:
-   // goto emulation
--  inf_leave: for (;;) {}
-+  for (;;) {}
- }
-```
-
-# Output
-
-```js
-{
-  inf_leave: for (;;) {} // goto emulation
-}
-{
-  inf_leave:
-  // goto emulation
-  for (;;) {}
-}
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/last-argument-expansion/arrow.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/last-argument-expansion/arrow.js.snap
index c1bc46f70af..4a4cad15690 100644
--- a/crates/rome_js_formatter/tests/specs/prettier/js/last-argument-expansion/arrow.js.snap
+++ b/crates/rome_js_formatter/tests/specs/prettier/js/last-argument-expansion/arrow.js.snap
@@ -1,5 +1,7 @@
 ---
 source: crates/rome_js_formatter/tests/prettier_tests.rs
+info:
+  test_file: js/last-argument-expansion/arrow.js
 ---
 
 # Input
@@ -28,7 +30,7 @@ export default function searchUsers(action$) {
 ```diff
 --- Prettier
 +++ Rome
-@@ -3,17 +3,20 @@
+@@ -3,17 +3,19 @@
      .ofType(ActionTypes.SEARCHED_USERS)
      .map((action) => action.payload.query)
      .filter((q) => !!q)
@@ -44,8 +46,7 @@ export default function searchUsers(action$) {
 -              .map(receiveUsers),
 +    .switchMap(
 +      (q) =>
-+        Observable.timer(800)
-+          // debounce
++        Observable.timer(800) // debounce
 +          .takeUntil(action$.ofType(ActionTypes.CLEARED_SEARCH_RESULTS))
 +          .mergeMap(
 +            () =>
@@ -72,8 +73,7 @@ export default function searchUsers(action$) {
     .filter((q) => !!q)
     .switchMap(
       (q) =>
-        Observable.timer(800)
-          // debounce
+        Observable.timer(800) // debounce
           .takeUntil(action$.ofType(ActionTypes.CLEARED_SEARCH_RESULTS))
           .mergeMap(
             () =>
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/last-argument-expansion/edge_case.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/last-argument-expansion/edge_case.js.snap
index fcd8d707bc0..7c705ad6596 100644
--- a/crates/rome_js_formatter/tests/specs/prettier/js/last-argument-expansion/edge_case.js.snap
+++ b/crates/rome_js_formatter/tests/specs/prettier/js/last-argument-expansion/edge_case.js.snap
@@ -1,5 +1,7 @@
 ---
 source: crates/rome_js_formatter/tests/prettier_tests.rs
+info:
+  test_file: js/last-argument-expansion/edge_case.js
 ---
 
 # Input
@@ -117,7 +119,7 @@ return /******/ (function(modules) { // webpackBootstrap
    },
  ];
  
-@@ -40,29 +40,28 @@
+@@ -40,29 +40,29 @@
    ],
  );
  
@@ -126,7 +128,29 @@ return /******/ (function(modules) { // webpackBootstrap
 -  function (__WEBPACK_EXTERNAL_MODULE_85__, __WEBPACK_EXTERNAL_MODULE_115__) {
 -    return /******/ (function (modules) {
 -      // webpackBootstrap
--      /******/
++(function webpackUniversalModuleDefinition() {})(this, function (
++  __WEBPACK_EXTERNAL_MODULE_85__,
++  __WEBPACK_EXTERNAL_MODULE_115__,
++) {
++  return /******/ (function (modules) {
++    // webpackBootstrap
++    /******/
++  })(
++    /************************************************************************/
++    /******/ [
++      /* 0 */
++      /***/ function (module, exports, __webpack_require__) {
++        /***/
++      },
++      /* 1 */
++      /***/ function (module, exports, __webpack_require__) {
++        /***/
++      },
++      /* 2 */
++      /***/ function (module, exports, __webpack_require__) {
++        /***/
++      },
+       /******/
 -    })(
 -      /************************************************************************/
 -      /******/ [
@@ -147,30 +171,8 @@ return /******/ (function(modules) { // webpackBootstrap
 -    );
 -  },
 -);
-+(function webpackUniversalModuleDefinition() {})(this, function (
-+  __WEBPACK_EXTERNAL_MODULE_85__,
-+  __WEBPACK_EXTERNAL_MODULE_115__,
-+) {
-+  return /******/ (function (modules) {
-+    // webpackBootstrap
-+    /******/
-+  })
-+  /************************************************************************/
-+  /******/ ([
-+    /* 0 */
-+    /***/ function (module, exports, __webpack_require__) {
-+      /***/
-+    },
-+    /* 1 */
-+    /***/ function (module, exports, __webpack_require__) {
-+      /***/
-+    },
-+    /* 2 */
-+    /***/ function (module, exports, __webpack_require__) {
-+      /***/
-+    },
-+    /******/
-+  ]);
++    ],
++  );
 +});
 ```
 
@@ -226,23 +228,24 @@ someReallyReallyReallyReallyReallyReallyReallyReallyReallyReallyReallyReallyReal
   return /******/ (function (modules) {
     // webpackBootstrap
     /******/
-  })
-  /************************************************************************/
-  /******/ ([
-    /* 0 */
-    /***/ function (module, exports, __webpack_require__) {
-      /***/
-    },
-    /* 1 */
-    /***/ function (module, exports, __webpack_require__) {
-      /***/
-    },
-    /* 2 */
-    /***/ function (module, exports, __webpack_require__) {
-      /***/
-    },
-    /******/
-  ]);
+  })(
+    /************************************************************************/
+    /******/ [
+      /* 0 */
+      /***/ function (module, exports, __webpack_require__) {
+        /***/
+      },
+      /* 1 */
+      /***/ function (module, exports, __webpack_require__) {
+        /***/
+      },
+      /* 2 */
+      /***/ function (module, exports, __webpack_require__) {
+        /***/
+      },
+      /******/
+    ],
+  );
 });
 ```
 
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/last-argument-expansion/empty-object.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/last-argument-expansion/empty-object.js.snap
deleted file mode 100644
index eb15b97d8d6..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/js/last-argument-expansion/empty-object.js.snap
+++ /dev/null
@@ -1,83 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-func(first, second, third, fourth, fifth, aReallyLongArgumentsListToForceItToBreak, {
-  // comment
-})
-
-func({
-  // comment
-})
-
-func(
-  {} // comment
-)
-
-func(
-  {}
-  // comment
-)
-
-func(
-  // comment
-  {}
-)
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -20,7 +20,7 @@
- 
- func(
-   {},
--  // comment
-+// comment
- );
- 
- func(
-```
-
-# Output
-
-```js
-func(
-  first,
-  second,
-  third,
-  fourth,
-  fifth,
-  aReallyLongArgumentsListToForceItToBreak,
-  {
-    // comment
-  },
-);
-
-func({
-  // comment
-});
-
-func(
-  {}, // comment
-);
-
-func(
-  {},
-// comment
-);
-
-func(
-  // comment
-  {},
-);
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/line-suffix-boundary/boundary.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/line-suffix-boundary/boundary.js.snap
deleted file mode 100644
index 810ee274d56..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/js/line-suffix-boundary/boundary.js.snap
+++ /dev/null
@@ -1,107 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-`${
-a +  // a
-  a
-}
-
-${a // comment
-}
-
-${b /* comment */}
-
-${/* comment */ c /* comment */}
-
-${// comment
-d //comment
-}
-
-${// $FlowFixMe found when converting React.createClass to ES6
-ExampleStory.getFragment('story')}
-`;
-
-<div>
-{ExampleStory.getFragment('story') // $FlowFixMe found when converting React.createClass to ES6
-}
-</div>;
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -3,23 +3,20 @@
-   a
- }
- 
--${
--  a // comment
-+${a // comment
- }
- 
- ${b /* comment */}
- 
- ${/* comment */ c /* comment */}
- 
--${
--  // comment
--  d //comment
-+${d // comment //comment
- }
- 
--${
-+${ExampleStory.getFragment(
-   // $FlowFixMe found when converting React.createClass to ES6
--  ExampleStory.getFragment("story")
--}
-+  "story",
-+)}
- `;
- 
- <div>
-```
-
-# Output
-
-```js
-`${
-  a + // a
-  a
-}
-
-${a // comment
-}
-
-${b /* comment */}
-
-${/* comment */ c /* comment */}
-
-${d // comment //comment
-}
-
-${ExampleStory.getFragment(
-  // $FlowFixMe found when converting React.createClass to ES6
-  "story",
-)}
-`;
-
-<div>
-  {
-    ExampleStory.getFragment("story") // $FlowFixMe found when converting React.createClass to ES6
-  }
-</div>;
-```
-
-
-# Lines exceeding max width of 80 characters
-```
-   24:     ExampleStory.getFragment("story") // $FlowFixMe found when converting React.createClass to ES6
-```
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/method-chain/comment.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/method-chain/comment.js.snap
index 47e436029bc..79f10844abd 100644
--- a/crates/rome_js_formatter/tests/specs/prettier/js/method-chain/comment.js.snap
+++ b/crates/rome_js_formatter/tests/specs/prettier/js/method-chain/comment.js.snap
@@ -1,5 +1,7 @@
 ---
 source: crates/rome_js_formatter/tests/prettier_tests.rs
+info:
+  test_file: js/method-chain/comment.js
 ---
 
 # Input
@@ -66,76 +68,28 @@ angular.module('AngularAppModule')
 ```diff
 --- Prettier
 +++ Rome
-@@ -1,10 +1,8 @@
- function f() {
--  return (
--    observableFromSubscribeFunction()
--      // Debounce manually rather than using editor.onDidStopChanging so that the debounce time is
--      // configurable.
--      .debounceTime(debounceInterval)
--  );
-+  return observableFromSubscribeFunction()
-+    // Debounce manually rather than using editor.onDidStopChanging so that the debounce time is
-+    // configurable.
-+    .debounceTime(debounceInterval);
- }
- 
- _.a(a)
-@@ -22,16 +20,17 @@
-   .a();
- 
- Something
--  // $FlowFixMe(>=0.41.0)
--  .getInstance(this.props.dao)
--  .getters();
-+// $FlowFixMe(>=0.41.0)
-+.getInstance(this.props.dao).getters();
- 
- // Warm-up first
--measure().then(() => {
--  SomethingLong();
--});
-+measure()
-+  .then(() => {
-+    SomethingLong();
-+  });
- 
--measure() // Warm-up first
-+measure()
-+  // Warm-up first
-   .then(() => {
-     SomethingLong();
-   });
-@@ -41,7 +40,8 @@
-   .consolidated // global/default values (do NOT modify)
-   .merge(this.cachedWorkspaceConfig);
- 
--this.doWriteConfiguration(target, value, options) // queue up writes to prevent race conditions
-+this.doWriteConfiguration(target, value, options)
-+  // queue up writes to prevent race conditions
-   .then(
-     () => null,
-     (error) => {
-@@ -52,7 +52,8 @@
-   );
+@@ -53,7 +53,8 @@
  
  ret = __DEV__
--  ? // $FlowFixMe: this type differs according to the env
-+  ?
-+    // $FlowFixMe: this type differs according to the env
-     vm.runInContext(source, ctx)
+   ? // $FlowFixMe: this type differs according to the env
+-    vm.runInContext(source, ctx)
++    vm
++      .runInContext(source, ctx)
    : a;
  
+ angular
 ```
 
 # Output
 
 ```js
 function f() {
-  return observableFromSubscribeFunction()
-    // Debounce manually rather than using editor.onDidStopChanging so that the debounce time is
-    // configurable.
-    .debounceTime(debounceInterval);
+  return (
+    observableFromSubscribeFunction()
+      // Debounce manually rather than using editor.onDidStopChanging so that the debounce time is
+      // configurable.
+      .debounceTime(debounceInterval)
+  );
 }
 
 _.a(a)
@@ -153,17 +107,16 @@ _.a(
   .a();
 
 Something
-// $FlowFixMe(>=0.41.0)
-.getInstance(this.props.dao).getters();
+  // $FlowFixMe(>=0.41.0)
+  .getInstance(this.props.dao)
+  .getters();
 
 // Warm-up first
-measure()
-  .then(() => {
-    SomethingLong();
-  });
+measure().then(() => {
+  SomethingLong();
+});
 
-measure()
-  // Warm-up first
+measure() // Warm-up first
   .then(() => {
     SomethingLong();
   });
@@ -173,8 +126,7 @@ const configModel = this.baseConfigurationService
   .consolidated // global/default values (do NOT modify)
   .merge(this.cachedWorkspaceConfig);
 
-this.doWriteConfiguration(target, value, options)
-  // queue up writes to prevent race conditions
+this.doWriteConfiguration(target, value, options) // queue up writes to prevent race conditions
   .then(
     () => null,
     (error) => {
@@ -185,9 +137,9 @@ this.doWriteConfiguration(target, value, options)
   );
 
 ret = __DEV__
-  ?
-    // $FlowFixMe: this type differs according to the env
-    vm.runInContext(source, ctx)
+  ? // $FlowFixMe: this type differs according to the env
+    vm
+      .runInContext(source, ctx)
   : a;
 
 angular
@@ -199,9 +151,10 @@ angular
 
 # Lines exceeding max width of 80 characters
 ```
-    3:     // Debounce manually rather than using editor.onDidStopChanging so that the debounce time is
-    9:   /* very very very very very very very long such that it is longer than 80 columns */
-   14: ) /* very very very very very very very long such that it is longer than 80 columns */
-   19: ) /* very very very very very very very long such that it is longer than 80 columns */
+    4:       // Debounce manually rather than using editor.onDidStopChanging so that the debounce time is
+   11:   /* very very very very very very very long such that it is longer than 80 columns */
+   16: ) /* very very very very very very very long such that it is longer than 80 columns */
+   21: ) /* very very very very very very very long such that it is longer than 80 columns */
+   44: this.doWriteConfiguration(target, value, options) // queue up writes to prevent race conditions
 ```
 
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/method-chain/issue-4125.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/method-chain/issue-4125.js.snap
index ab9ebddbd5d..f568ae0a27d 100644
--- a/crates/rome_js_formatter/tests/specs/prettier/js/method-chain/issue-4125.js.snap
+++ b/crates/rome_js_formatter/tests/specs/prettier/js/method-chain/issue-4125.js.snap
@@ -1,5 +1,7 @@
 ---
 source: crates/rome_js_formatter/tests/prettier_tests.rs
+info:
+  test_file: js/method-chain/issue-4125.js
 ---
 
 # Input
@@ -162,17 +164,7 @@ var l = base
 ```diff
 --- Prettier
 +++ Rome
-@@ -19,7 +19,8 @@
- 
- // you can still force multi-line chaining with a comment:
- const sha256_2 = (data) =>
--  crypto // breakme
-+  crypto
-+    // breakme
-     .createHash("sha256")
-     .update(data)
-     .digest("hex");
-@@ -44,7 +45,8 @@
+@@ -44,7 +44,8 @@
  
  // examples from https://github.com/prettier/prettier/issues/1565
  
@@ -182,7 +174,7 @@ var l = base
    .selectAll("p")
    .data([1, 2, 3])
    .enter()
-@@ -67,7 +69,10 @@
+@@ -67,7 +68,10 @@
  
  db.branch(
    db.table("users").filter({ email }).count(),
@@ -194,17 +186,7 @@ var l = base
    db.table("users").insert({ email }),
    db.table("users").filter({ email }),
  );
-@@ -78,7 +83,8 @@
- 
- fetchUser(id).then(fetchAccountForUser).catch(handleFetchError);
- 
--fetchUser(id) //
-+fetchUser(id)
-+  //
-   .then(fetchAccountForUser)
-   .catch(handleFetchError);
- 
-@@ -90,39 +96,40 @@
+@@ -90,39 +94,39 @@
      authorizationToken: data.token,
    }).initVerify("foo_container");
  
@@ -254,8 +236,7 @@ var l = base
 -            .map(receiveUsers),
 +  .switchMap(
 +    (q) =>
-+      Observable.timer(800)
-+        // debounce
++      Observable.timer(800) // debounce
 +        .takeUntil(action$.ofType(ActionTypes.CLEARED_SEARCH_RESULTS))
 +        .mergeMap(
 +          () =>
@@ -271,7 +252,7 @@ var l = base
    );
  
  window.FooClient.setVars({
-@@ -138,21 +145,32 @@
+@@ -138,21 +142,32 @@
  const a1 = x.a(true).b(null).c(123);
  const a2 = x.d("").e(``).f(g);
  const a3 = x.d("").e(`${123}`).f(g);
@@ -309,7 +290,7 @@ var l = base
    .b(`${c(d())}`)
    .f();
  
-@@ -161,7 +179,4 @@
+@@ -161,7 +176,4 @@
    .b()
    .c(a(a(b(c(d().p).p).p).p));
  
@@ -344,8 +325,7 @@ somePromise
 
 // you can still force multi-line chaining with a comment:
 const sha256_2 = (data) =>
-  crypto
-    // breakme
+  crypto // breakme
     .createHash("sha256")
     .update(data)
     .digest("hex");
@@ -408,8 +388,7 @@ const date = moment.utc(userInput).hour(0).minute(0).second(0);
 
 fetchUser(id).then(fetchAccountForUser).catch(handleFetchError);
 
-fetchUser(id)
-  //
+fetchUser(id) //
   .then(fetchAccountForUser)
   .catch(handleFetchError);
 
@@ -442,8 +421,7 @@ action$
   .filter((q) => !!q)
   .switchMap(
     (q) =>
-      Observable.timer(800)
-        // debounce
+      Observable.timer(800) // debounce
         .takeUntil(action$.ofType(ActionTypes.CLEARED_SEARCH_RESULTS))
         .mergeMap(
           () =>
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/module-blocks/comments.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/module-blocks/comments.js.snap
index f279535c6a2..8959291cf82 100644
--- a/crates/rome_js_formatter/tests/specs/prettier/js/module-blocks/comments.js.snap
+++ b/crates/rome_js_formatter/tests/specs/prettier/js/module-blocks/comments.js.snap
@@ -1,5 +1,7 @@
 ---
 source: crates/rome_js_formatter/tests/prettier_tests.rs
+info:
+  test_file: js/module-blocks/comments.js
 ---
 
 # Input
@@ -26,7 +28,7 @@ const m2 = module/* B1 */{
 @@ -1,12 +1,13 @@
 -const m = /*A1*/ module {
 -  /*A2*/ /*A3*/
-+const m = /*A1*/ module /*A2*/;
++const m = /*A1*/ module; /*A2*/
 +{
 +  /*A3*/
    /*A4*/
@@ -38,7 +40,7 @@ const m2 = module/* B1 */{
  
 -const m2 = module {
 -  /* B1 */
-+const m2 = module /* B1 */;
++const m2 = module; /* B1 */
 +{
    /* B2 */
 -};
@@ -48,7 +50,7 @@ const m2 = module/* B1 */{
 # Output
 
 ```js
-const m = /*A1*/ module /*A2*/;
+const m = /*A1*/ module; /*A2*/
 {
   /*A3*/
   /*A4*/
@@ -57,7 +59,7 @@ const m = /*A1*/ module /*A2*/;
   /*A6*/
 } /*A7*/ /*A8*/
 
-const m2 = module /* B1 */;
+const m2 = module; /* B1 */
 {
   /* B2 */
 }
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/multiparser-comments/comment-inside.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/multiparser-comments/comment-inside.js.snap
index 2f63f1fdd1d..43ce5280a60 100644
--- a/crates/rome_js_formatter/tests/specs/prettier/js/multiparser-comments/comment-inside.js.snap
+++ b/crates/rome_js_formatter/tests/specs/prettier/js/multiparser-comments/comment-inside.js.snap
@@ -1,5 +1,7 @@
 ---
 source: crates/rome_js_formatter/tests/prettier_tests.rs
+info:
+  test_file: js/multiparser-comments/comment-inside.js
 ---
 
 # Input
@@ -74,48 +76,38 @@ expr1 = html`
 ```diff
 --- Prettier
 +++ Rome
-@@ -3,56 +3,43 @@
-   <div>
-     ${
-       this.set && this.set.artist
--      /* avoid console errors if `this.set` is undefined */
--    }
-+/* avoid console errors if `this.set` is undefined */}
-   </div>
- `;
- 
--html`${
--  foo
--  /* comment */
-+html`${foo
-+/* comment */
+@@ -13,36 +13,32 @@
+   /* comment */
  }`;
  html`
 -  ${
 -    foo
 -    /* comment */
 -  }
-+${foo
-+/* comment */
++${
++  foo
++  /* comment */
 +}
  `;
  
--graphql`
++graphql`${
++  foo
++  /* comment */
++}`;
+ graphql`
 -  ${
 -    foo
 -    /* comment */
 -  }
 -`;
-+graphql`${foo
-+/* comment */
-+}`;
- graphql`
+-graphql`
 -  ${
 -    foo
 -    /* comment */
 -  }
-+${foo
-+/* comment */
++${
++  foo
++  /* comment */
 +}
  `;
  
@@ -125,35 +117,23 @@ expr1 = html`
 -    /* comment */
 -  }
 -`;
-+css`${foo
-+/* comment */
++css`${
++  foo
++  /* comment */
 +}`;
  css`
 -  ${
 -    foo
 -    /* comment */
 -  }
-+${foo
-+/* comment */
++${
++  foo
++  /* comment */
 +}
  `;
  
--markdown`${
--  foo
--  /* comment */
-+markdown`${foo
-+/* comment */
- }`;
- markdown`
--${
--  foo
--  /* comment */
-+${foo
-+/* comment */
- }
- `;
- 
-@@ -62,6 +49,5 @@
+ markdown`${
+@@ -62,6 +58,5 @@
      ${x(
        foo, // fg
        bar,
@@ -171,43 +151,52 @@ html`
   <div>
     ${
       this.set && this.set.artist
-/* avoid console errors if `this.set` is undefined */}
+      /* avoid console errors if `this.set` is undefined */
+    }
   </div>
 `;
 
-html`${foo
-/* comment */
+html`${
+  foo
+  /* comment */
 }`;
 html`
-${foo
-/* comment */
+${
+  foo
+  /* comment */
 }
 `;
 
-graphql`${foo
-/* comment */
+graphql`${
+  foo
+  /* comment */
 }`;
 graphql`
-${foo
-/* comment */
+${
+  foo
+  /* comment */
 }
 `;
 
-css`${foo
-/* comment */
+css`${
+  foo
+  /* comment */
 }`;
 css`
-${foo
-/* comment */
+${
+  foo
+  /* comment */
 }
 `;
 
-markdown`${foo
-/* comment */
+markdown`${
+  foo
+  /* comment */
 }`;
 markdown`
-${foo
-/* comment */
+${
+  foo
+  /* comment */
 }
 `;
 
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
deleted file mode 100644
index 4c36614c966..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/js/object-property-comment/after-key.js.snap
+++ /dev/null
@@ -1,48 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-let a = {
-   a /* comment */: () => 1
-};
-
-let b = {
-   "a" /* comment */: () => 1
-};
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -1,7 +1,7 @@
- let a = {
--  a /* comment */: () => 1,
-+  a /* comment */ : () => 1,
- };
- 
- let b = {
--  a /* comment */: () => 1,
-+  a /* comment */ : () => 1,
- };
-```
-
-# Output
-
-```js
-let a = {
-  a /* comment */ : () => 1,
-};
-
-let b = {
-  a /* comment */ : () => 1,
-};
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/object-property-ignore/ignore.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/object-property-ignore/ignore.js.snap
deleted file mode 100644
index bf4a07d1dd9..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/js/object-property-ignore/ignore.js.snap
+++ /dev/null
@@ -1,134 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-foo = {
-  // prettier-ignore
-  bar:            1,
-}
-
-foo = {
-  _: '',
-  // prettier-ignore
-  bar:            1,
-}
-
-/* comments */
-foo = {
-  _: '',
-  // prettier-ignore
-  bar:            1,         // comment
-}
-
-foo = {
-  _: '',
-  // prettier-ignore
-  bar:            1,         /* comment */
-}
-
-foo = {
-  _: '',
-  // prettier-ignore
-  bar:            /* comment */          1,
-}
-
-/* SpreadElement */
-foo = {
-  _: '',
-  // prettier-ignore
-  ...bar,
-}
-
-// Nested
-foo = {
-  baz: {
-  // prettier-ignore
-  foo: [1, 2,    3]
-},
-  // prettier-ignore
-  bar:            1,
-}
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -19,7 +19,7 @@
- foo = {
-   _: "",
-   // prettier-ignore
--  bar:            1 /* comment */,
-+  bar:            1, /* comment */
- };
- 
- foo = {
-@@ -39,7 +39,7 @@
- foo = {
-   baz: {
-     // prettier-ignore
--    foo: [1, 2,    3],
-+  foo: [1, 2,    3],
-   },
-   // prettier-ignore
-   bar:            1,
-```
-
-# Output
-
-```js
-foo = {
-  // prettier-ignore
-  bar:            1,
-};
-
-foo = {
-  _: "",
-  // prettier-ignore
-  bar:            1,
-};
-
-/* comments */
-foo = {
-  _: "",
-  // prettier-ignore
-  bar:            1, // comment
-};
-
-foo = {
-  _: "",
-  // prettier-ignore
-  bar:            1, /* comment */
-};
-
-foo = {
-  _: "",
-  // prettier-ignore
-  bar:            /* comment */          1,
-};
-
-/* SpreadElement */
-foo = {
-  _: "",
-  // prettier-ignore
-  ...bar,
-};
-
-// Nested
-foo = {
-  baz: {
-    // prettier-ignore
-  foo: [1, 2,    3],
-  },
-  // prettier-ignore
-  bar:            1,
-};
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/object-property-ignore/issue-5678.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/object-property-ignore/issue-5678.js.snap
deleted file mode 100644
index 3042c24c37d..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/js/object-property-ignore/issue-5678.js.snap
+++ /dev/null
@@ -1,137 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-// #5678
-const refreshTokenPayload = {
-    type: 'refreshToken',
-    sub: this._id,
-    role: this.role,
-  	// prettier-ignore
-    exp: now + (60 * 60 * 24 * 90), // (90 days)
-  };
-
-export default {
-  // prettier-ignore
-  protagonist: "  0\r\n" +
-               "0 00\r\n" +
-               "00000\r\n" +
-               "0 0\r\n" +
-               "0 0",
-
-  // prettier-ignore
-  wall: "00000\r\n" +
-        "00000\r\n" +
-        "00000\r\n" +
-        "00000\r\n" +
-        "00000",
-
-  // prettier-ignore
-  cheese: "0\r\n" +
-          " 0\r\n" +
-          "000\r\n" +
-          "00 0\r\n" +
-          "00000",
-
-  // prettier-ignore
-  enemy: "0   0\r\n" +
-         "00 00\r\n" +
-         "00000\r\n" +
-         "0 0 0\r\n" +
-         "00000",
-
-  // prettier-ignore
-  home: "00000\r\n" +
-        "0   0\r\n" +
-        "0   0\r\n" +
-        "0   0\r\n" +
-        "00000",
-
-  // prettier-ignore
-  dog: "00 00\r\n" +
-       "00000\r\n" +
-       "0   0\r\n" +
-       "0 0 0\r\n" +
-       " 000 "
-}
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -4,7 +4,7 @@
-   sub: this._id,
-   role: this.role,
-   // prettier-ignore
--  exp: now + (60 * 60 * 24 * 90), // (90 days)
-+    exp: now + (60 * 60 * 24 * 90), // (90 days)
- };
- 
- export default {
-```
-
-# Output
-
-```js
-// #5678
-const refreshTokenPayload = {
-  type: "refreshToken",
-  sub: this._id,
-  role: this.role,
-  // prettier-ignore
-    exp: now + (60 * 60 * 24 * 90), // (90 days)
-};
-
-export default {
-  // prettier-ignore
-  protagonist: "  0\r\n" +
-               "0 00\r\n" +
-               "00000\r\n" +
-               "0 0\r\n" +
-               "0 0",
-
-  // prettier-ignore
-  wall: "00000\r\n" +
-        "00000\r\n" +
-        "00000\r\n" +
-        "00000\r\n" +
-        "00000",
-
-  // prettier-ignore
-  cheese: "0\r\n" +
-          " 0\r\n" +
-          "000\r\n" +
-          "00 0\r\n" +
-          "00000",
-
-  // prettier-ignore
-  enemy: "0   0\r\n" +
-         "00 00\r\n" +
-         "00000\r\n" +
-         "0 0 0\r\n" +
-         "00000",
-
-  // prettier-ignore
-  home: "00000\r\n" +
-        "0   0\r\n" +
-        "0   0\r\n" +
-        "0   0\r\n" +
-        "00000",
-
-  // prettier-ignore
-  dog: "00 00\r\n" +
-       "00000\r\n" +
-       "0   0\r\n" +
-       "0 0 0\r\n" +
-       " 000 ",
-};
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/optional-chaining/comments.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/optional-chaining/comments.js.snap
index 220f5437f30..cee76a51803 100644
--- a/crates/rome_js_formatter/tests/specs/prettier/js/optional-chaining/comments.js.snap
+++ b/crates/rome_js_formatter/tests/specs/prettier/js/optional-chaining/comments.js.snap
@@ -1,5 +1,7 @@
 ---
 source: crates/rome_js_formatter/tests/prettier_tests.rs
+info:
+  test_file: js/optional-chaining/comments.js
 ---
 
 # Input
@@ -59,22 +61,7 @@ foo.bar.baz
 ```diff
 --- Prettier
 +++ Rome
-@@ -1,48 +1,35 @@
- function foo() {
--  return (
--    a
--      .b()
--      .c()
--      // Comment
--      ?.d()
--  );
-+  return a
-+    .b()
-+    .c()
-+    // Comment
-+    ?.d();
- }
- 
+@@ -11,38 +11,27 @@
  fooBar
    .doSomething("Hello World")
    .doAnotherThing("Foo", { foo: bar })
@@ -119,11 +106,13 @@ foo.bar.baz
 
 ```js
 function foo() {
-  return a
-    .b()
-    .c()
-    // Comment
-    ?.d();
+  return (
+    a
+      .b()
+      .c()
+      // Comment
+      ?.d()
+  );
 }
 
 fooBar
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/preserve-line/argument-list.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/preserve-line/argument-list.js.snap
index c37edf4379c..937b213a8d2 100644
--- a/crates/rome_js_formatter/tests/specs/prettier/js/preserve-line/argument-list.js.snap
+++ b/crates/rome_js_formatter/tests/specs/prettier/js/preserve-line/argument-list.js.snap
@@ -1,5 +1,7 @@
 ---
 source: crates/rome_js_formatter/tests/prettier_tests.rs
+info:
+  test_file: js/preserve-line/argument-list.js
 ---
 
 # Input
@@ -250,26 +252,21 @@ function foo(
    /* Another comment */
  
    // Long Long Long Long Long Comment
-@@ -35,69 +27,50 @@
-   // Long Long Long Long Long Comment
- 
-   short3,
--  // More comments
--);
-+// More comments
+@@ -38,28 +30,21 @@
+   // More comments
+ );
  
 -differentArgTypes(
 -  () => {
 -    return true;
 -  },
--
--  isTrue ? doSomething() : 12,
- );
- 
 +differentArgTypes(() => {
 +  return true;
 +}, isTrue ? doSomething() : 12);
-+
+ 
+-  isTrue ? doSomething() : 12,
+-);
+-
  moreArgTypes(
    [1, 2, 3],
 -
@@ -285,10 +282,9 @@ function foo(
      { name: "Hello World", age: 34 },
 -
      oneThing + anotherThing,
-+  // Comment
  
--    // Comment
-   ),
+     // Comment
+@@ -67,37 +52,24 @@
  );
  
  evenMoreArgTypes(
@@ -315,22 +311,22 @@ function foo(
  
 -bar.on(
 -  "readable",
-+bar.on("readable", () => {
-+  doStuff();
-+});
- 
+-
 -  () => {
 -    doStuff();
 -  },
 -);
--
++bar.on("readable", () => {
++  doStuff();
++});
+ 
  foo(
    ["A, B"],
 -
    /* function here */
    function doSomething() {
      return true;
-@@ -106,33 +79,22 @@
+@@ -106,33 +78,22 @@
  
  doSomething.apply(
    null,
@@ -342,7 +338,11 @@ function foo(
  
 -doAnotherThing(
 -  "node",
--
++doAnotherThing("node", {
++  solution_type,
++  time_frame,
++});
+ 
 -  {
 -    solution_type,
 -    time_frame,
@@ -351,11 +351,7 @@ function foo(
 -
 -stuff.doThing(
 -  someStuff,
-+doAnotherThing("node", {
-+  solution_type,
-+  time_frame,
-+});
- 
+-
 -  -1,
 -  {
 -    accept: (node) => doSomething(node),
@@ -371,7 +367,7 @@ function foo(
    // This is important
    true,
    {
-@@ -140,19 +102,13 @@
+@@ -140,19 +101,13 @@
    },
  );
  
@@ -428,8 +424,7 @@ comments(
   // Long Long Long Long Long Comment
 
   short3,
-// More comments
-
+  // More comments
 );
 
 differentArgTypes(() => {
@@ -448,8 +443,8 @@ moreArgTypes(
     // Hello world again
     { name: "Hello World", age: 34 },
     oneThing + anotherThing,
-  // Comment
 
+    // Comment
   ),
 );
 
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/return/comment.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/return/comment.js.snap
deleted file mode 100644
index 2808b3c7ed4..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/js/return/comment.js.snap
+++ /dev/null
@@ -1,143 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-function f() {
-  return /* a */;
-}
-
-function f() {
-  return // a
-  ;
-}
-
-function f() {
-  return // a
-  /* b */;
-}
-
-function f() {
-  return /* a */
-  // b
-  ;
-}
-
-function x() {
-  return func2
-      //comment
-      .bar();
-}
-
-function f() {
-  return (
-    foo
-      // comment
-      .bar()
-  );
-}
-
-fn(function f() {
-  return (
-    foo
-      // comment
-      .bar()
-  );
-});
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -12,30 +12,25 @@
- }
- 
- function f() {
--  return; /* a */
-+  return /* a */
-   // b
-+  ;
- }
- 
- function x() {
--  return (
--    func2
--      //comment
--      .bar()
--  );
-+  return func2
-+  //comment
-+  .bar();
- }
- 
- function f() {
--  return (
--    foo
--      // comment
--      .bar()
--  );
-+  return foo
-+  // comment
-+  .bar();
- }
- 
- fn(function f() {
--  return (
--    foo
--      // comment
--      .bar()
--  );
-+  return foo
-+  // comment
-+  .bar();
- });
-```
-
-# Output
-
-```js
-function f() {
-  return /* a */;
-}
-
-function f() {
-  return; // a
-}
-
-function f() {
-  return // a
-  /* b */;
-}
-
-function f() {
-  return /* a */
-  // b
-  ;
-}
-
-function x() {
-  return func2
-  //comment
-  .bar();
-}
-
-function f() {
-  return foo
-  // comment
-  .bar();
-}
-
-fn(function f() {
-  return foo
-  // comment
-  .bar();
-});
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/switch/comments.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/switch/comments.js.snap
deleted file mode 100644
index 2359d0de753..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/js/switch/comments.js.snap
+++ /dev/null
@@ -1,159 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-switch (true) {
-  case true:
-  // Good luck getting here
-
-  case false:
-}
-
-switch (true) {
-  case true:
-
-  // Good luck getting here
-  case false:
-}
-
-switch(x) {
-  case x: {
-  }
-
-  // other
-
-  case y: {
-  }
-}
-
-switch(x) {
-  default: // comment
-    break;
-}
-
-switch(x) {
-  default: // comment
-    {break;}
-}
-
-switch(x) {
-  default: {// comment
-    break;}
-}
-
-switch(x) {
-  default: /* comment */
-    break;
-}
-
-switch(x) {
-  default: /* comment */
-    {break;}
-}
-
-switch(x) {
-  default: {/* comment */
-    break;}
-}
-
-switch(x) {
-  default: /* comment */ {
-    break;}
-}
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -23,7 +23,8 @@
- }
- 
- switch (x) {
--  default: // comment
-+  default:
-+    // comment
-     break;
- }
- 
-```
-
-# Output
-
-```js
-switch (true) {
-  case true:
-  // Good luck getting here
-
-  case false:
-}
-
-switch (true) {
-  case true:
-
-  // Good luck getting here
-  case false:
-}
-
-switch (x) {
-  case x: {
-  }
-
-  // other
-
-  case y: {
-  }
-}
-
-switch (x) {
-  default:
-    // comment
-    break;
-}
-
-switch (x) {
-  default: {
-    // comment
-    break;
-  }
-}
-
-switch (x) {
-  default: {
-    // comment
-    break;
-  }
-}
-
-switch (x) {
-  default: /* comment */
-    break;
-}
-
-switch (x) {
-  default: /* comment */ {
-    break;
-  }
-}
-
-switch (x) {
-  default: {
-    /* comment */
-    break;
-  }
-}
-
-switch (x) {
-  default: /* comment */ {
-    break;
-  }
-}
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/template/comment.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/template/comment.js.snap
deleted file mode 100644
index 4745afa1e1e..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/js/template/comment.js.snap
+++ /dev/null
@@ -1,60 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-`
-(?:${escapeChar}[\\S\\s]|(?:(?!${// Using `XRegExp.union` safely rewrites backreferences in `left` and `right`.
-// Intentionally not passing `basicFlags` to `XRegExp.union` since any syntax
-// transformation resulting from those flags was already applied to `left` and
-// `right` when they were passed through the XRegExp constructor above.
-XRegExp.union([left, right], '', {conjunction: 'or'}).source})[^${escapeChar}])+)+
-`;
-
-`a${/* b */c/* d */}e${// f
-g
-// h
-}`;
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -8,8 +8,6 @@
- })[^${escapeChar}])+)+
- `;
- 
--`a${/* b */ c /* d */}e${
--  // f
--  g
--  // h
-+`a${/* b */ c /* d */}e${g // f
-+// h
- }`;
-```
-
-# Output
-
-```js
-`
-(?:${escapeChar}[\\S\\s]|(?:(?!${
-  // Using `XRegExp.union` safely rewrites backreferences in `left` and `right`.
-  // Intentionally not passing `basicFlags` to `XRegExp.union` since any syntax
-  // transformation resulting from those flags was already applied to `left` and
-  // `right` when they were passed through the XRegExp constructor above.
-  XRegExp.union([left, right], "", { conjunction: "or" }).source
-})[^${escapeChar}])+)+
-`;
-
-`a${/* b */ c /* d */}e${g // f
-// h
-}`;
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/ternaries/nested.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/ternaries/nested.js.snap
deleted file mode 100644
index 5b3a410ba4b..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/js/ternaries/nested.js.snap
+++ /dev/null
@@ -1,226 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-let icecream = what == "cone"
-  ? p => !!p ? `here's your ${p} cone` : `just the empty cone for you`
-  : p => `here's your ${p} ${what}`;
-
-const value = condition1
-? value1
-: condition2
-    ? value2
-    : condition3
-        ? value3
-        : value4;
-
-
-const StorybookLoader = ({ match }) => (
-  match.params.storyId === "button"
-    ? <ButtonStorybook />
-    : match.params.storyId === "color"
-    ? <ColorBook />
-    : match.params.storyId === "typography"
-    ? <TypographyBook />
-    : match.params.storyId === "loading"
-    ? <LoaderStorybook />
-    : match.params.storyId === "deal-list"
-    ? <DealListStory />
-    : (
-      <Message>
-        <Title>{'Missing story book'}</Title>
-        <Content>
-          <BackButton/>
-        </Content>
-      </Message>
-    )
-)
-
-const message =
-    i % 3 === 0 && i % 5 === 0 ?
-        'fizzbuzz'
-    : i % 3 === 0 ?
-        'fizz'
-    : i % 5 === 0 ?
-        'buzz'
-    :
-        String(i)
-
-const paymentMessage = state == 'success'
-  ? 'Payment completed successfully'
-
-: state == 'processing'
-  ? 'Payment processing'
-
-: state == 'invalid_cvc'
-  ? 'There was an issue with your CVC number'
-
-: state == 'invalid_expiry'
-  ? 'Expiry must be sometime in the past.'
-
-  : 'There was an issue with the payment.  Please contact support.'
-
-const paymentMessage2 = state == 'success'
-  ? 1 //'Payment completed successfully'
-
-: state == 'processing'
-  ? 2 //'Payment processing'
-
-: state == 'invalid_cvc'
-  ? 3 //'There was an issue with your CVC number'
-
-: true //state == 'invalid_expiry'
-  ? 4 //'Expiry must be sometime in the past.'
-
-  : 5 // 'There was an issue with the payment.  Please contact support.'
-
-const foo = <div className={'match-achievement-medal-type type' + (medals[0].record ? '-record' : (medals[0].unique ? '-unique' : medals[0].type))}>
-	{medals[0].record ? (
-		i18n('Record')
-	) : medals[0].unique ? (
-		i18n('Unique')
-	) : medals[0].type === 0 ? (
-		i18n('Silver')
-	) : medals[0].type === 1 ? (
-		i18n('Gold')
-	) : medals[0].type === 2 ? (
-		i18n('Platinum')
-	) : (
-		i18n('Theme')
-	)}
-</div>
-
-a
-    ? literalline
-    : {
-      123: 12
-    }
-    ? line
-    : softline
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -60,7 +60,8 @@
-     ? 3 //'There was an issue with your CVC number'
-     : true //state == 'invalid_expiry'
-     ? 4 //'Expiry must be sometime in the past.'
--    : 5; // 'There was an issue with the payment.  Please contact support.'
-+    : 5 // 'There was an issue with the payment.  Please contact support.'
-+    ;
- 
- const foo = (
-   <div
-```
-
-# Output
-
-```js
-let icecream =
-  what == "cone"
-    ? (p) => (!!p ? `here's your ${p} cone` : `just the empty cone for you`)
-    : (p) => `here's your ${p} ${what}`;
-
-const value = condition1
-  ? value1
-  : condition2
-  ? value2
-  : condition3
-  ? value3
-  : value4;
-
-const StorybookLoader = ({ match }) =>
-  match.params.storyId === "button" ? (
-    <ButtonStorybook />
-  ) : match.params.storyId === "color" ? (
-    <ColorBook />
-  ) : match.params.storyId === "typography" ? (
-    <TypographyBook />
-  ) : match.params.storyId === "loading" ? (
-    <LoaderStorybook />
-  ) : match.params.storyId === "deal-list" ? (
-    <DealListStory />
-  ) : (
-    <Message>
-      <Title>{"Missing story book"}</Title>
-      <Content>
-        <BackButton />
-      </Content>
-    </Message>
-  );
-
-const message =
-  i % 3 === 0 && i % 5 === 0
-    ? "fizzbuzz"
-    : i % 3 === 0
-    ? "fizz"
-    : i % 5 === 0
-    ? "buzz"
-    : String(i);
-
-const paymentMessage =
-  state == "success"
-    ? "Payment completed successfully"
-    : state == "processing"
-    ? "Payment processing"
-    : state == "invalid_cvc"
-    ? "There was an issue with your CVC number"
-    : state == "invalid_expiry"
-    ? "Expiry must be sometime in the past."
-    : "There was an issue with the payment.  Please contact support.";
-
-const paymentMessage2 =
-  state == "success"
-    ? 1 //'Payment completed successfully'
-    : state == "processing"
-    ? 2 //'Payment processing'
-    : state == "invalid_cvc"
-    ? 3 //'There was an issue with your CVC number'
-    : true //state == 'invalid_expiry'
-    ? 4 //'Expiry must be sometime in the past.'
-    : 5 // 'There was an issue with the payment.  Please contact support.'
-    ;
-
-const foo = (
-  <div
-    className={
-      "match-achievement-medal-type type" +
-      (medals[0].record
-        ? "-record"
-        : medals[0].unique
-        ? "-unique"
-        : medals[0].type)
-    }
-  >
-    {medals[0].record
-      ? i18n("Record")
-      : medals[0].unique
-      ? i18n("Unique")
-      : medals[0].type === 0
-      ? i18n("Silver")
-      : medals[0].type === 1
-      ? i18n("Gold")
-      : medals[0].type === 2
-      ? i18n("Platinum")
-      : i18n("Theme")}
-  </div>
-);
-
-a
-  ? literalline
-  : {
-      123: 12,
-    }
-  ? line
-  : softline;
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/throw_statement/comment.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/throw_statement/comment.js.snap
deleted file mode 100644
index 549d73adf0f..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/js/throw_statement/comment.js.snap
+++ /dev/null
@@ -1,95 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-function x() {
-  throw func2
-      //comment
-      .bar();
-}
- 
-function f() {
-  throw (
-    foo
-      // comment
-      .bar()
-  );
-}
- 
-fn(function f() {
-  throw (
-    foo
-      // comment
-      .bar()
-  );
-});
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -1,23 +1,17 @@
- function x() {
--  throw (
--    func2
--      //comment
--      .bar()
--  );
-+  throw func2
-+  //comment
-+  .bar();
- }
- 
- function f() {
--  throw (
--    foo
--      // comment
--      .bar()
--  );
-+  throw foo
-+  // comment
-+  .bar();
- }
- 
- fn(function f() {
--  throw (
--    foo
--      // comment
--      .bar()
--  );
-+  throw foo
-+  // comment
-+  .bar();
- });
-```
-
-# Output
-
-```js
-function x() {
-  throw func2
-  //comment
-  .bar();
-}
-
-function f() {
-  throw foo
-  // comment
-  .bar();
-}
-
-fn(function f() {
-  throw foo
-  // comment
-  .bar();
-});
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/trailing-comma/trailing_whitespace.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/trailing-comma/trailing_whitespace.js.snap
deleted file mode 100644
index 7e736ed49a8..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/js/trailing-comma/trailing_whitespace.js.snap
+++ /dev/null
@@ -1,137 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-let example = [
-  'FOO',
-  'BAR',
-  // Comment
-];
-
-foo({},
-  // Comment
-);
-
-o = {
-  state,
-  // Comment
-};
-
-o = {
-  state,
-
-  // Comment
-};
-
-function supersupersupersuperLongF(
-  supersupersupersuperLongA,
-  supersupersupersuperLongB
-  // Comment
-) {
-  a
-}
-function supersupersupersuperLongF(
-  supersupersupersuperLongA,
-  supersupersupersuperLongB,
-  // Comment
-) {
-  a
-}
-
-this.getAttribute(function(s)
-  /*string*/ {
-  console.log()
-});
-this.getAttribute(function(s) /*string*/ {
-  console.log()
-});
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -6,7 +6,7 @@
- 
- foo(
-   {},
--  // Comment
-+// Comment
- );
- 
- o = {
-@@ -16,7 +16,6 @@
- 
- o = {
-   state,
--
-   // Comment
- };
- 
-@@ -35,7 +34,8 @@
-   a;
- }
- 
--this.getAttribute(function (s) /*string*/ {
-+this.getAttribute(function (s)
-+/*string*/ {
-   console.log();
- });
- this.getAttribute(function (s) /*string*/ {
-```
-
-# Output
-
-```js
-let example = [
-  "FOO",
-  "BAR",
-  // Comment
-];
-
-foo(
-  {},
-// Comment
-);
-
-o = {
-  state,
-  // Comment
-};
-
-o = {
-  state,
-  // Comment
-};
-
-function supersupersupersuperLongF(
-  supersupersupersuperLongA,
-  supersupersupersuperLongB,
-  // Comment
-) {
-  a;
-}
-function supersupersupersuperLongF(
-  supersupersupersuperLongA,
-  supersupersupersuperLongB,
-  // Comment
-) {
-  a;
-}
-
-this.getAttribute(function (s)
-/*string*/ {
-  console.log();
-});
-this.getAttribute(function (s) /*string*/ {
-  console.log();
-});
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/try/catch.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/try/catch.js.snap
deleted file mode 100644
index 8cf97185203..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/js/try/catch.js.snap
+++ /dev/null
@@ -1,84 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-try {}
-catch(
-  // comment
-  foo
-) {}
-
-try {}
-catch(foo //comment
-) {}
-
-try {}
-catch(
-  /* comment */ foo
-) {}
-
-try {}
-catch(
-  foo /* comment */
-) {}
-
-try {}
-catch(
-  foo
-  /* comment */
-) {}
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -10,7 +10,9 @@
- ) {}
- 
- try {
--} catch (/* comment */ foo) {}
-+} catch (
-+  /* comment */ foo
-+) {}
- 
- try {
- } catch (foo /* comment */) {}
-```
-
-# Output
-
-```js
-try {
-} catch (
-  // comment
-  foo
-) {}
-
-try {
-} catch (
-  foo //comment
-) {}
-
-try {
-} catch (
-  /* comment */ foo
-) {}
-
-try {
-} catch (foo /* comment */) {}
-
-try {
-} catch (
-  foo
-  /* comment */
-) {}
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/try/try.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/try/try.js.snap
deleted file mode 100644
index 50eb40eaa74..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/js/try/try.js.snap
+++ /dev/null
@@ -1,41 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-try
-/* missing comment */
-{;}
-finally {}
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -1,4 +1,5 @@
--try {
--  /* missing comment */
-+try
-+/* missing comment */
-+{
- } finally {
- }
-```
-
-# Output
-
-```js
-try
-/* missing comment */
-{
-} finally {
-}
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/js/unary-expression/comments.js.snap b/crates/rome_js_formatter/tests/specs/prettier/js/unary-expression/comments.js.snap
deleted file mode 100644
index 5c661aa0bee..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/js/unary-expression/comments.js.snap
+++ /dev/null
@@ -1,840 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-!x;
-!(x /* foo */);
-!(/* foo */ x);
-!(
-  /* foo */
-  x
-);
-!(
-  x
-  /* foo */
-);
-!(
-  x // foo
-);
-
-!(x + y);
-!(x + y /* foo */);
-!(/* foo */ x + y);
-!(
-  /* foo */
-  x + y
-);
-!(
-  x + y
-  /* foo */
-);
-!(
-  x + y // foo
-);
-
-!(x || y);
-!(/* foo */ x || y);
-!(x || y /* foo */);
-!(
-  /* foo */
-  x || y
-);
-!(
-  x || y
-  /* foo */
-);
-!(
-  x || y // foo
-);
-
-![1, 2, 3];
-!([1, 2, 3] /* foo */);
-!(/* foo */ [1, 2, 3]);
-!(
-  /* foo */
-  [1, 2, 3]
-);
-!(
-  [1, 2, 3]
-  /* foo */
-);
-!(
-  [1, 2, 3] // foo
-);
-
-!{ a: 1, b: 2 };
-!({ a: 1, b: 2 } /* foo */);
-!(/* foo */ { a: 1, b: 2 });
-!(
-  /* foo */
-  { a: 1, b: 2 }
-);
-!(
-  { a: 1, b: 2 }
-  /* foo */
-);
-!(
-  { a: 1, b: 2 } // foo
-)
-
-!function() {
-  return x;
-};
-!(
-  function() {
-    return x;
-  } /* foo */
-);
-!(
-  /* foo */ function() {
-    return x;
-  }
-);
-!(
-  /* foo */
-  function() {
-    return x;
-  }
-);
-!(
-  function() {
-    return x;
-  }
-  /* foo */
-);
-!(
-  function() {
-    return x;
-  } // foo
-)
-
-!+3;
-!(+3 /* foo */);
-!(/* foo */ +3);
-!(
-  /* foo */
-  +3
-);
-!(
-  +3
-  /* foo */
-);
-!(
-  +3 // foo
-);
-
-!+(
-  /* foo */
-  3
-);
-!(/* foo */ +(3 /* foo */));
-!(+(3 /* foo */) /* foo */);
-!(
-  /* foo */
-  +(
-    /* foo */
-    3
-  )
-);
-!(
-  +(
-    3
-    /* foo */
-  )
-  /* foo */
-);
-!(
-  +(
-    3 /* foo */
-  ) // foo
-);
-
-!(x = y);
-!(x = y /* foo */);
-!(/* foo */ x = y);
-!(
-  /* foo */
-  x = y
-);
-!(
-  x = y
-  /* foo */
-);
-!(
-  x = y // foo
-);
-
-!x.y;
-!(x.y /* foo */);
-!(/* foo */ x.y);
-!(
-  /* foo */
-  x.y
-);
-!(
-  x.y
-  /* foo */
-);
-!(
-  x.y // foo
-);
-
-!(x ? y : z);
-!(x ? y : z /* foo */);
-!(/* foo */ x ? y : z);
-!(
-  /* foo */
-  x ? y : z
-);
-!(
-  x ? y : z
-  /* foo */
-);
-!(
-  x ? y : z // foo
-);
-
-!x();
-!(x() /* foo */);
-!(/* foo */ x());
-!(
-  /* foo */
-  x()
-);
-!(
-  x()
-  /* foo */
-);
-!(
-  x() // foo
-);
-
-!new x();
-!(new x() /* foo */);
-!(/* foo */ new x());
-!(
-  /* foo */
-  new x()
-);
-!(
-  new x()
-  /* foo */
-);
-!(
-  new x() // foo
-);
-
-!(x, y);
-!(x, y /* foo */);
-!(/* foo */ x, y);
-!(
-  /* foo */
-  x, y
-);
-!(
-  x, y
-  /* foo */
-);
-!(
-  x.y // foo
-);
-
-!(() => 3);
-!(() => 3 /* foo */);
-!(/* foo */ () => 3);
-!(
-  /* foo */
-  () => 3
-);
-!(
-  () => 3
-  /* foo */
-);
-!(
-  () => 3 // foo
-);
-
-function* bar() {
-  !(yield x);
-  !(yield x /* foo */);
-  !(/* foo */ yield x);
-  !(
-    /* foo */
-    yield x
-  );
-  !(
-    yield x
-    /* foo */
-  );
-  !(
-    yield x // foo
-  );
-}
-
-async function bar2() {
-  !(await x);
-  !(await x /* foo */);
-  !(/* foo */ await x);
-  !(
-  /* foo */
-  await x
-  );
-  !(
-    await x
-    /* foo */
-  );
-  !(
-    await x // foo
-  );
-}
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -1,86 +1,59 @@
- !x;
--!(x /* foo */);
-+!x /* foo */;
- !(/* foo */ x);
- !(
-   /* foo */
-   x
- );
--!(
--  x
--  /* foo */
--);
--!(
--  x // foo
--);
-+!x /* foo */;
-+!x; // foo
- 
- !(x + y);
--!((x + y) /* foo */);
-+!(x + y) /* foo */;
- !(/* foo */ (x + y));
- !(
-   /* foo */
-   (x + y)
- );
--!(
--  (x + y)
--  /* foo */
--);
--!(
--  (x + y) // foo
--);
-+!(x + y) /* foo */;
-+!(x + y); // foo
- 
- !(x || y);
- !(/* foo */ (x || y));
--!((x || y) /* foo */);
-+!(x || y) /* foo */;
- !(
-   /* foo */
-   (x || y)
- );
--!(
--  (x || y)
--  /* foo */
--);
--!(
--  (x || y) // foo
--);
-+!(x || y) /* foo */;
-+!(x || y); // foo
- 
- ![1, 2, 3];
--!([1, 2, 3] /* foo */);
-+![1, 2, 3] /* foo */;
- !(/* foo */ [1, 2, 3]);
- !(
-   /* foo */
-   [1, 2, 3]
- );
--!(
--  [1, 2, 3]
--  /* foo */
--);
--!(
--  [1, 2, 3] // foo
--);
-+![1, 2, 3] /* foo */;
-+![1, 2, 3]; // foo
- 
- !{ a: 1, b: 2 };
--!({ a: 1, b: 2 } /* foo */);
-+!{ a: 1, b: 2 } /* foo */;
- !(/* foo */ { a: 1, b: 2 });
- !(
-   /* foo */
-   { a: 1, b: 2 }
- );
--!(
--  { a: 1, b: 2 }
--  /* foo */
--);
--!(
--  { a: 1, b: 2 } // foo
--);
-+!{ a: 1, b: 2 } /* foo */;
-+!{ a: 1, b: 2 }; // foo
- 
- !function () {
-   return x;
- };
--!(
--  function () {
--    return x;
--  } /* foo */
--);
-+!function () {
-+  return x;
-+} /* foo */;
- !(
-   /* foo */ function () {
-     return x;
-@@ -92,39 +65,29 @@
-     return x;
-   }
- );
--!(
--  function () {
--    return x;
--  }
--  /* foo */
--);
--!(
--  function () {
--    return x;
--  } // foo
--);
-+!function () {
-+  return x;
-+} /* foo */;
-+!function () {
-+  return x;
-+}; // foo
- 
- !+3;
--!(+3 /* foo */);
-+!+3 /* foo */;
- !(/* foo */ +3);
- !(
-   /* foo */
-   +3
- );
--!(
--  +3
--  /* foo */
--);
--!(
--  +3 // foo
--);
-+!+3 /* foo */;
-+!+3; // foo
- 
- !+(
-   /* foo */
-   3
- );
--!(/* foo */ +(3 /* foo */));
--!(+(3 /* foo */) /* foo */);
-+!(/* foo */ +3 /* foo */);
-+!+3 /* foo */ /* foo */;
- !(
-   /* foo */
-   +(
-@@ -132,152 +95,99 @@
-     3
-   )
- );
--!(
--  +(
--    3
--    /* foo */
--  )
--  /* foo */
--);
--!(
--  +(3 /* foo */) // foo
--);
-+!+3 /* foo */ /* foo */;
-+!+3 /* foo */; // foo
- 
- !(x = y);
--!((x = y) /* foo */);
-+!(x = y) /* foo */;
- !(/* foo */ (x = y));
- !(
-   /* foo */
-   (x = y)
- );
--!(
--  (x = y)
--  /* foo */
--);
--!(
--  (x = y) // foo
--);
-+!(x = y) /* foo */;
-+!(x = y); // foo
- 
- !x.y;
--!(x.y /* foo */);
-+!x.y /* foo */;
- !(/* foo */ x.y);
- !(
-   /* foo */
-   x.y
- );
--!(
--  x.y
--  /* foo */
--);
--!(
--  x.y // foo
--);
-+!x.y /* foo */;
-+!x.y; // foo
- 
- !(x ? y : z);
--!((x ? y : z) /* foo */);
-+!(x ? y : z) /* foo */;
- !(/* foo */ (x ? y : z));
- !(
-   /* foo */
-   (x ? y : z)
- );
--!(
--  (x ? y : z)
--  /* foo */
--);
--!(
--  (x ? y : z) // foo
--);
-+!(x ? y : z) /* foo */;
-+!(x ? y : z); // foo
- 
- !x();
--!(x() /* foo */);
-+!x() /* foo */;
- !(/* foo */ x());
- !(
-   /* foo */
-   x()
- );
--!(
--  x()
--  /* foo */
--);
--!(
--  x() // foo
--);
-+!x() /* foo */;
-+!x(); // foo
- 
- !new x();
--!(new x() /* foo */);
-+!new x() /* foo */;
- !(/* foo */ new x());
- !(
-   /* foo */
-   new x()
- );
--!(
--  new x()
--  /* foo */
--);
--!(
--  new x() // foo
--);
-+!new x() /* foo */;
-+!new x(); // foo
- 
- !(x, y);
--!((x, y) /* foo */);
-+!(x, y) /* foo */;
- !(/* foo */ (x, y));
- !(
-   /* foo */
-   (x, y)
- );
--!(
--  (x, y)
--  /* foo */
--);
--!(
--  x.y // foo
--);
-+!(x, y) /* foo */;
-+!x.y; // foo
- 
- !(() => 3);
--!((() => 3) /* foo */);
-+!(() => 3) /* foo */;
- !(/* foo */ (() => 3));
- !(
-   /* foo */
-   (() => 3)
- );
--!(
--  (() => 3)
--  /* foo */
--);
--!(
--  (() => 3) // foo
--);
-+!(() => 3) /* foo */;
-+!(() => 3); // foo
- 
- function* bar() {
-   !(yield x);
--  !((yield x) /* foo */);
-+  !(yield x) /* foo */;
-   !(/* foo */ (yield x));
-   !(
-     /* foo */
-     (yield x)
-   );
--  !(
--    (yield x)
--    /* foo */
--  );
--  !(
--    (yield x) // foo
--  );
-+  !(yield x) /* foo */;
-+  !(yield x); // foo
- }
- 
- async function bar2() {
-   !(await x);
--  !((await x) /* foo */);
-+  !(await x) /* foo */;
-   !(/* foo */ (await x));
-   !(
-     /* foo */
-     (await x)
-   );
--  !(
--    (await x)
--    /* foo */
--  );
--  !(
--    (await x) // foo
--  );
-+  !(await x) /* foo */;
-+  !(await x); // foo
- }
-```
-
-# Output
-
-```js
-!x;
-!x /* foo */;
-!(/* foo */ x);
-!(
-  /* foo */
-  x
-);
-!x /* foo */;
-!x; // foo
-
-!(x + y);
-!(x + y) /* foo */;
-!(/* foo */ (x + y));
-!(
-  /* foo */
-  (x + y)
-);
-!(x + y) /* foo */;
-!(x + y); // foo
-
-!(x || y);
-!(/* foo */ (x || y));
-!(x || y) /* foo */;
-!(
-  /* foo */
-  (x || y)
-);
-!(x || y) /* foo */;
-!(x || y); // foo
-
-![1, 2, 3];
-![1, 2, 3] /* foo */;
-!(/* foo */ [1, 2, 3]);
-!(
-  /* foo */
-  [1, 2, 3]
-);
-![1, 2, 3] /* foo */;
-![1, 2, 3]; // foo
-
-!{ a: 1, b: 2 };
-!{ a: 1, b: 2 } /* foo */;
-!(/* foo */ { a: 1, b: 2 });
-!(
-  /* foo */
-  { a: 1, b: 2 }
-);
-!{ a: 1, b: 2 } /* foo */;
-!{ a: 1, b: 2 }; // foo
-
-!function () {
-  return x;
-};
-!function () {
-  return x;
-} /* foo */;
-!(
-  /* foo */ function () {
-    return x;
-  }
-);
-!(
-  /* foo */
-  function () {
-    return x;
-  }
-);
-!function () {
-  return x;
-} /* foo */;
-!function () {
-  return x;
-}; // foo
-
-!+3;
-!+3 /* foo */;
-!(/* foo */ +3);
-!(
-  /* foo */
-  +3
-);
-!+3 /* foo */;
-!+3; // foo
-
-!+(
-  /* foo */
-  3
-);
-!(/* foo */ +3 /* foo */);
-!+3 /* foo */ /* foo */;
-!(
-  /* foo */
-  +(
-    /* foo */
-    3
-  )
-);
-!+3 /* foo */ /* foo */;
-!+3 /* foo */; // foo
-
-!(x = y);
-!(x = y) /* foo */;
-!(/* foo */ (x = y));
-!(
-  /* foo */
-  (x = y)
-);
-!(x = y) /* foo */;
-!(x = y); // foo
-
-!x.y;
-!x.y /* foo */;
-!(/* foo */ x.y);
-!(
-  /* foo */
-  x.y
-);
-!x.y /* foo */;
-!x.y; // foo
-
-!(x ? y : z);
-!(x ? y : z) /* foo */;
-!(/* foo */ (x ? y : z));
-!(
-  /* foo */
-  (x ? y : z)
-);
-!(x ? y : z) /* foo */;
-!(x ? y : z); // foo
-
-!x();
-!x() /* foo */;
-!(/* foo */ x());
-!(
-  /* foo */
-  x()
-);
-!x() /* foo */;
-!x(); // foo
-
-!new x();
-!new x() /* foo */;
-!(/* foo */ new x());
-!(
-  /* foo */
-  new x()
-);
-!new x() /* foo */;
-!new x(); // foo
-
-!(x, y);
-!(x, y) /* foo */;
-!(/* foo */ (x, y));
-!(
-  /* foo */
-  (x, y)
-);
-!(x, y) /* foo */;
-!x.y; // foo
-
-!(() => 3);
-!(() => 3) /* foo */;
-!(/* foo */ (() => 3));
-!(
-  /* foo */
-  (() => 3)
-);
-!(() => 3) /* foo */;
-!(() => 3); // foo
-
-function* bar() {
-  !(yield x);
-  !(yield x) /* foo */;
-  !(/* foo */ (yield x));
-  !(
-    /* foo */
-    (yield x)
-  );
-  !(yield x) /* foo */;
-  !(yield x); // foo
-}
-
-async function bar2() {
-  !(await x);
-  !(await x) /* foo */;
-  !(/* foo */ (await x));
-  !(
-    /* foo */
-    (await x)
-  );
-  !(await x) /* foo */;
-  !(await x); // foo
-}
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/jsx/fragment/fragment.js.snap b/crates/rome_js_formatter/tests/specs/prettier/jsx/fragment/fragment.js.snap
deleted file mode 100644
index 24a6be4d5ab..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/jsx/fragment/fragment.js.snap
+++ /dev/null
@@ -1,202 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
-info:
-  test_file: jsx/fragment/fragment.js
----
-
-# Input
-
-```js
-<></>;
-
-<>
-   text
-</>;
-
-<>
-  <Component />
-  <Component />
-</>;
-
-<>
-  text
-  <h2>heading</h2>
-  text
-  <h2>heading</h2>
-  text
-</>;
-
-<div>
-  <>
-    <>
-      <span>Hello</span>
-      <span>world</span>
-    </>
-    <>
-      <span>Goodbye</span>
-      <span>world</span>
-    </>
-  </>
-</div>;
-
-foo = (
-  // comment
-  <></>
-);
-
-</* open fragment */>
-  <Component />
-  <Component />
-</ /* close fragment */>;
-
-< // open fragment
->
-  <Component />
-  <Component />
-</ // close fragment
->;
-
-[<></>, <></>];
-const fun1 = () => <></>;
-x = <></>
-function fun2(param = <></>) {}
-1 + <></>;
-1 || <></>;
-fun2(<></>);
-test ? <></> : x;
-<></>;
-<a>
-  <></>
-</a>;
-const obj = {
-  foo: <></>
-};
-const fragmentVar = <></>;
-function fun3() {
-  return <></>;
-}
-(<></>).toString();
-(<></>).props;
-(<></>)["computed"];
-(<></>)["computed"]();
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -28,24 +28,22 @@
-   </>
- </div>;
- 
--foo = (
--  // comment
--  <></>
--);
-+foo =
-+  (
-+    // comment
-+    <></>
-+  );
- 
--</* open fragment */>
-+< /* open fragment */ >
-   <Component />
-   <Component />
--</ /* close fragment */>;
-+</ /* close fragment */ >;
- 
--<
-+<>
-   // open fragment
-->
-   <Component />
-   <Component />
--</
--  // close fragment
-->;
-+</>; // close fragment
- 
- [<></>, <></>];
- const fun1 = () => <></>;
-```
-
-# Output
-
-```js
-<></>;
-
-<>text</>;
-
-<>
-  <Component />
-  <Component />
-</>;
-
-<>
-  text
-  <h2>heading</h2>
-  text
-  <h2>heading</h2>
-  text
-</>;
-
-<div>
-  <>
-    <>
-      <span>Hello</span>
-      <span>world</span>
-    </>
-    <>
-      <span>Goodbye</span>
-      <span>world</span>
-    </>
-  </>
-</div>;
-
-foo =
-  (
-    // comment
-    <></>
-  );
-
-< /* open fragment */ >
-  <Component />
-  <Component />
-</ /* close fragment */ >;
-
-<>
-  // open fragment
-  <Component />
-  <Component />
-</>; // close fragment
-
-[<></>, <></>];
-const fun1 = () => <></>;
-x = <></>;
-function fun2(param = <></>) {}
-1 + <></>;
-1 || <></>;
-fun2(<></>);
-test ? <></> : x;
-<></>;
-<a>
-  <></>
-</a>;
-const obj = {
-  foo: <></>,
-};
-const fragmentVar = <></>;
-function fun3() {
-  return <></>;
-}
-(<></>).toString();
-(<></>).props;
-(<></>)["computed"];
-(<></>)["computed"]();
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/jsx/ignore/jsx_ignore.js b/crates/rome_js_formatter/tests/specs/prettier/jsx/ignore/jsx_ignore.js
index f540cd8b2a8..c19f8db1b14 100644
--- a/crates/rome_js_formatter/tests/specs/prettier/jsx/ignore/jsx_ignore.js
+++ b/crates/rome_js_formatter/tests/specs/prettier/jsx/ignore/jsx_ignore.js
@@ -47,7 +47,6 @@ push(
 );
 
 function f() {
-	// rome-ignore format: Instability issue
   return (
     // prettier-ignore
     /* $FlowFixMe(>=0.53.0) */
diff --git a/crates/rome_js_formatter/tests/specs/prettier/jsx/ignore/jsx_ignore.js.snap b/crates/rome_js_formatter/tests/specs/prettier/jsx/ignore/jsx_ignore.js.snap
deleted file mode 100644
index 7d74b6711bf..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/jsx/ignore/jsx_ignore.js.snap
+++ /dev/null
@@ -1,193 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
-info:
-  test_file: jsx/ignore/jsx_ignore.js
----
-
-# Input
-
-```js
-// this should remain as-is
-<div>
- {/* prettier-ignore */}
- <style jsx global>{ComponentStyles}</style>
-</div>;
-
-// this should remain as-is
-<div>
- {/* prettier-ignore */}
- <span     ugly  format=''   />
-</div>;
-
-// this should remain as-is
-f(
-  <Component>
-    {/*prettier-ignore*/}
-    <span     ugly  format=''   />
-  </Component>
-);
-
-// this be formatted
-<div>
-  {/* prettier-ignore */} foo
-  <Bar   excessive    spaces    />
-</div>;
-
-// this should remain as-is
-<div>
-{
-  /* prettier-ignore */
-  foo ( )
-}
-</div>;
-
-// this should remain as-is
-<div>
-{
-  /* prettier-ignore */
-  x     ?   <Y/> : <Z/>
-}
-</div>;
-
-push(
-  // prettier-ignore
-  <td> :)
-  </td>,
-);
-
-function f() {
-	// rome-ignore format: Instability issue
-  return (
-    // prettier-ignore
-    /* $FlowFixMe(>=0.53.0) */
-    <JSX />
-  );
-}
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -1,20 +1,22 @@
- // this should remain as-is
- <div>
-   {/* prettier-ignore */}
--  <style jsx global>{ComponentStyles}</style>
-+  <style jsx global>
-+    {ComponentStyles}
-+  </style>
- </div>;
- 
- // this should remain as-is
- <div>
-   {/* prettier-ignore */}
--  <span     ugly  format=''   />
-+  <span ugly format='' />
- </div>;
- 
- // this should remain as-is
- f(
-   <Component>
-     {/*prettier-ignore*/}
--    <span     ugly  format=''   />
-+    <span ugly format='' />
-   </Component>,
- );
- 
-@@ -28,16 +30,15 @@
- <div>
-   {
-     /* prettier-ignore */
--    foo ( )
-+  foo ( )
-   }
- </div>;
- 
- // this should remain as-is
- <div>
-   {
--    /* prettier-ignore */
--    x     ?   <Y/> : <Z/>
--  }
-+  /* prettier-ignore */
-+  x     ?   <Y/> : <Z/>}
- </div>;
- 
- push(
-@@ -47,6 +48,7 @@
- );
- 
- function f() {
-+  // rome-ignore format: Instability issue
-   return (
-     // prettier-ignore
-     /* $FlowFixMe(>=0.53.0) */
-```
-
-# Output
-
-```js
-// this should remain as-is
-<div>
-  {/* prettier-ignore */}
-  <style jsx global>
-    {ComponentStyles}
-  </style>
-</div>;
-
-// this should remain as-is
-<div>
-  {/* prettier-ignore */}
-  <span ugly format='' />
-</div>;
-
-// this should remain as-is
-f(
-  <Component>
-    {/*prettier-ignore*/}
-    <span ugly format='' />
-  </Component>,
-);
-
-// this be formatted
-<div>
-  {/* prettier-ignore */} foo
-  <Bar excessive spaces />
-</div>;
-
-// this should remain as-is
-<div>
-  {
-    /* prettier-ignore */
-  foo ( )
-  }
-</div>;
-
-// this should remain as-is
-<div>
-  {
-  /* prettier-ignore */
-  x     ?   <Y/> : <Z/>}
-</div>;
-
-push(
-  // prettier-ignore
-  <td> :)
-  </td>,
-);
-
-function f() {
-  // rome-ignore format: Instability issue
-  return (
-    // prettier-ignore
-    /* $FlowFixMe(>=0.53.0) */
-    <JSX />
-  );
-}
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/jsx/split-attrs/test.js b/crates/rome_js_formatter/tests/specs/prettier/jsx/split-attrs/test.js
index 59f3a7a8ae1..4ae4a5d6565 100644
--- a/crates/rome_js_formatter/tests/specs/prettier/jsx/split-attrs/test.js
+++ b/crates/rome_js_formatter/tests/specs/prettier/jsx/split-attrs/test.js
@@ -44,6 +44,5 @@ long_string =
 long_string_with_extra_param =
   <div className="i use bootstrap and just put loooaads of classnames in here all the time" blah="3">hello world</div>
 
-// rome-ignore format: Instability issue
 long_obj =
   <div style={{ i: 'dont', use: 'bootstrap', and: 'instead', use: 'massive', objects }}>hello world</div>
diff --git a/crates/rome_js_formatter/tests/specs/prettier/jsx/split-attrs/test.js.snap b/crates/rome_js_formatter/tests/specs/prettier/jsx/split-attrs/test.js.snap
deleted file mode 100644
index 9042378ed7f..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/jsx/split-attrs/test.js.snap
+++ /dev/null
@@ -1,261 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
-info:
-  test_file: jsx/split-attrs/test.js
----
-
-# Input
-
-```js
-long_closed =
-  <BaseForm url="/auth/google" method="GET" colour="blue" size="large" submitLabel="Sign in with Google"/>
-
-long_open =
-  <BaseForm url="/auth/google" method="GET" colour="blue" size="large" submitLabel="Sign in with Google">
-    hello
-  </BaseForm>
-
-long_open_long_children =
-  <BaseForm url="/auth/google" method="GET" colour="blue" size="large" submitLabel="Sign in with Google">
-    <BaseForm url="/auth/google" method="GET" colour="blue" size="large" submitLabel="Sign in with Google">
-      Hello world
-    </BaseForm>
-    <div><div><div><div><div><div>hey hiya how are ya</div></div></div></div></div></div>
-    <div><div><div><div attr="long" attr2="also long" attr3="gonna break"></div></div></div></div>
-    <div><div><div>
-      <div attr="long" attr2="also long" attr3="gonna break" attr4="hello please break me" />
-    </div></div></div>
-    <BaseForm url="/auth/google" method="GET" colour="blue" size="large" submitLabel="Sign in with Google"><BaseForm url="/auth/google" method="GET" colour="blue" size="large" submitLabel="Sign in with Google"></BaseForm>d</BaseForm>
-    <BaseForm url="/auth/google" method="GET" colour="blue" size="large" submitLabel="Sign in with Google"><BaseForm url="/auth/google" method="GET" colour="blue" size="large" submitLabel="Sign in with Google"></BaseForm></BaseForm>
-  </BaseForm>
-
-short_closed =
-  <BaseForm url="/auth/google" method="GET"/>
-
-short_open =
-  <BaseForm url="/auth/google" method="GET">
-    hello
-  </BaseForm>
-
-make_self_closing =
-  <div>
-    <BaseForm url="/auth/google" method="GET" colour="blue" size="large" submitLabel="Sign in with Google">
-    </BaseForm>
-    <BaseForm url="/auth/google" method="GET" colour="blue" size="large" submitLabel="Sign in with Google"></BaseForm>
-  </div>
-
-leave_opening =
-  <BaseForm url="/auth/google" method="GET" colour="blue" size="large" submitLabel="Sign in with Google"> </BaseForm>
-
-long_string =
-  <div className="i use bootstrap and just put loooaads of classnames in here all the time">hello world</div>
-
-long_string_with_extra_param =
-  <div className="i use bootstrap and just put loooaads of classnames in here all the time" blah="3">hello world</div>
-
-// rome-ignore format: Instability issue
-long_obj =
-  <div style={{ i: 'dont', use: 'bootstrap', and: 'instead', use: 'massive', objects }}>hello world</div>
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -155,16 +155,6 @@
-   </div>
- );
- 
--long_obj = (
--  <div
--    style={{
--      i: "dont",
--      use: "bootstrap",
--      and: "instead",
--      use: "massive",
--      objects,
--    }}
--  >
--    hello world
--  </div>
--);
-+// rome-ignore format: Instability issue
-+long_obj =
-+  <div style={{ i: 'dont', use: 'bootstrap', and: 'instead', use: 'massive', objects }}>hello world</div>
-```
-
-# Output
-
-```js
-long_closed = (
-  <BaseForm
-    url="/auth/google"
-    method="GET"
-    colour="blue"
-    size="large"
-    submitLabel="Sign in with Google"
-  />
-);
-
-long_open = (
-  <BaseForm
-    url="/auth/google"
-    method="GET"
-    colour="blue"
-    size="large"
-    submitLabel="Sign in with Google"
-  >
-    hello
-  </BaseForm>
-);
-
-long_open_long_children = (
-  <BaseForm
-    url="/auth/google"
-    method="GET"
-    colour="blue"
-    size="large"
-    submitLabel="Sign in with Google"
-  >
-    <BaseForm
-      url="/auth/google"
-      method="GET"
-      colour="blue"
-      size="large"
-      submitLabel="Sign in with Google"
-    >
-      Hello world
-    </BaseForm>
-    <div>
-      <div>
-        <div>
-          <div>
-            <div>
-              <div>hey hiya how are ya</div>
-            </div>
-          </div>
-        </div>
-      </div>
-    </div>
-    <div>
-      <div>
-        <div>
-          <div attr="long" attr2="also long" attr3="gonna break"></div>
-        </div>
-      </div>
-    </div>
-    <div>
-      <div>
-        <div>
-          <div
-            attr="long"
-            attr2="also long"
-            attr3="gonna break"
-            attr4="hello please break me"
-          />
-        </div>
-      </div>
-    </div>
-    <BaseForm
-      url="/auth/google"
-      method="GET"
-      colour="blue"
-      size="large"
-      submitLabel="Sign in with Google"
-    >
-      <BaseForm
-        url="/auth/google"
-        method="GET"
-        colour="blue"
-        size="large"
-        submitLabel="Sign in with Google"
-      ></BaseForm>
-      d
-    </BaseForm>
-    <BaseForm
-      url="/auth/google"
-      method="GET"
-      colour="blue"
-      size="large"
-      submitLabel="Sign in with Google"
-    >
-      <BaseForm
-        url="/auth/google"
-        method="GET"
-        colour="blue"
-        size="large"
-        submitLabel="Sign in with Google"
-      ></BaseForm>
-    </BaseForm>
-  </BaseForm>
-);
-
-short_closed = <BaseForm url="/auth/google" method="GET" />;
-
-short_open = (
-  <BaseForm url="/auth/google" method="GET">
-    hello
-  </BaseForm>
-);
-
-make_self_closing = (
-  <div>
-    <BaseForm
-      url="/auth/google"
-      method="GET"
-      colour="blue"
-      size="large"
-      submitLabel="Sign in with Google"
-    ></BaseForm>
-    <BaseForm
-      url="/auth/google"
-      method="GET"
-      colour="blue"
-      size="large"
-      submitLabel="Sign in with Google"
-    ></BaseForm>
-  </div>
-);
-
-leave_opening = (
-  <BaseForm
-    url="/auth/google"
-    method="GET"
-    colour="blue"
-    size="large"
-    submitLabel="Sign in with Google"
-  >
-    {" "}
-  </BaseForm>
-);
-
-long_string = (
-  <div className="i use bootstrap and just put loooaads of classnames in here all the time">
-    hello world
-  </div>
-);
-
-long_string_with_extra_param = (
-  <div
-    className="i use bootstrap and just put loooaads of classnames in here all the time"
-    blah="3"
-  >
-    hello world
-  </div>
-);
-
-// rome-ignore format: Instability issue
-long_obj =
-  <div style={{ i: 'dont', use: 'bootstrap', and: 'instead', use: 'massive', objects }}>hello world</div>
-```
-
-
-# Lines exceeding max width of 80 characters
-```
-  144:   <div className="i use bootstrap and just put loooaads of classnames in here all the time">
-  151:     className="i use bootstrap and just put loooaads of classnames in here all the time"
-  160:   <div style={{ i: 'dont', use: 'bootstrap', and: 'instead', use: 'massive', objects }}>hello world</div>
-```
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/jsx/spread/attribute.js.snap b/crates/rome_js_formatter/tests/specs/prettier/jsx/spread/attribute.js.snap
index 39071cb7e1f..179fb709d7c 100644
--- a/crates/rome_js_formatter/tests/specs/prettier/jsx/spread/attribute.js.snap
+++ b/crates/rome_js_formatter/tests/specs/prettier/jsx/spread/attribute.js.snap
@@ -40,40 +40,33 @@ info:
 ```diff
 --- Prettier
 +++ Rome
-@@ -9,28 +9,21 @@
- <div {/* comment */ ...a} />;
+@@ -6,7 +6,7 @@
  
- <div
--  {
--    ...a //comment
--  }
-+  {...a} //comment
- />;
+ <div {...a /* comment */} />;
+ 
+-<div {/* comment */ ...a} />;
++<div {.../* comment */ a} />;
  
  <div
--  {
--    ...a
--    //comment
-+  {...a
-+  //comment
-   }
- />;
+   {
+@@ -23,14 +23,14 @@
  
  <div
    {
 -    //comment
 -    ...a
--  }
-+  //comment
-+  ...a}
++    ...//comment
++    a
+   }
  />;
  
  <div
--  {
+   {
 -    //comment
 -    ...a // comment
--  }
-+  {...a} //comment // comment
++    ...//comment
++    a // comment
+   }
  />;
 ```
 
@@ -88,26 +81,33 @@ info:
 
 <div {...a /* comment */} />;
 
-<div {/* comment */ ...a} />;
+<div {.../* comment */ a} />;
 
 <div
-  {...a} //comment
+  {
+    ...a //comment
+  }
 />;
 
 <div
-  {...a
-  //comment
+  {
+    ...a
+    //comment
   }
 />;
 
 <div
   {
-  //comment
-  ...a}
+    ...//comment
+    a
+  }
 />;
 
 <div
-  {...a} //comment // comment
+  {
+    ...//comment
+    a // comment
+  }
 />;
 ```
 
diff --git a/crates/rome_js_formatter/tests/specs/prettier/jsx/spread/child.js b/crates/rome_js_formatter/tests/specs/prettier/jsx/spread/child.js
index 94e59bf6d24..c8798b1e0d2 100644
--- a/crates/rome_js_formatter/tests/specs/prettier/jsx/spread/child.js
+++ b/crates/rome_js_formatter/tests/specs/prettier/jsx/spread/child.js
@@ -4,7 +4,6 @@
 
 <div>{/* comment */...a}</div>;
 
-// rome-ignore format: Instability issue
 <div>{...a //comment
 }</div>;
 
@@ -17,7 +16,6 @@
   ...a
 }</div>;
 
-// rome-ignore format: Instability issue
 <div>{//comment
   ...a // comment
 }</div>;
diff --git a/crates/rome_js_formatter/tests/specs/prettier/jsx/spread/child.js.snap b/crates/rome_js_formatter/tests/specs/prettier/jsx/spread/child.js.snap
index 5358e69534a..c07cc5252c9 100644
--- a/crates/rome_js_formatter/tests/specs/prettier/jsx/spread/child.js.snap
+++ b/crates/rome_js_formatter/tests/specs/prettier/jsx/spread/child.js.snap
@@ -13,7 +13,6 @@ info:
 
 <div>{/* comment */...a}</div>;
 
-// rome-ignore format: Instability issue
 <div>{...a //comment
 }</div>;
 
@@ -26,7 +25,6 @@ info:
   ...a
 }</div>;
 
-// rome-ignore format: Instability issue
 <div>{//comment
   ...a // comment
 }</div>;
@@ -38,47 +36,34 @@ info:
 ```diff
 --- Prettier
 +++ Rome
-@@ -4,29 +4,23 @@
+@@ -2,7 +2,7 @@
  
- <div>{/* comment */ ...a}</div>;
+ <div>{...a /* comment */}</div>;
  
--<div>
--  {
--    ...a //comment
--  }
--</div>;
-+// rome-ignore format: Instability issue
-+<div>{...a //comment
-+}</div>;
+-<div>{/* comment */ ...a}</div>;
++<div>{.../* comment */ a}</div>;
  
  <div>
--  {
--    ...a
--    //comment
-+  {...a
-+  //comment
-   }
- </div>;
+   {
+@@ -19,14 +19,14 @@
  
  <div>
    {
 -    //comment
 -    ...a
--  }
-+  //comment
-+  ...a}
++    ...//comment
++    a
+   }
  </div>;
  
--<div>
--  {
+ <div>
+   {
 -    //comment
 -    ...a // comment
--  }
--</div>;
-+// rome-ignore format: Instability issue
-+<div>{//comment
-+  ...a // comment
-+}</div>;
++    ...//comment
++    a // comment
+   }
+ </div>;
 ```
 
 # Output
@@ -88,28 +73,34 @@ info:
 
 <div>{...a /* comment */}</div>;
 
-<div>{/* comment */ ...a}</div>;
+<div>{.../* comment */ a}</div>;
 
-// rome-ignore format: Instability issue
-<div>{...a //comment
-}</div>;
+<div>
+  {
+    ...a //comment
+  }
+</div>;
 
 <div>
-  {...a
-  //comment
+  {
+    ...a
+    //comment
   }
 </div>;
 
 <div>
   {
-  //comment
-  ...a}
+    ...//comment
+    a
+  }
 </div>;
 
-// rome-ignore format: Instability issue
-<div>{//comment
-  ...a // comment
-}</div>;
+<div>
+  {
+    ...//comment
+    a // comment
+  }
+</div>;
 ```
 
 
diff --git a/crates/rome_js_formatter/tests/specs/prettier/typescript/arrow/comments.ts.snap b/crates/rome_js_formatter/tests/specs/prettier/typescript/arrow/comments.ts.snap
index fad26202e0f..14d52ed8780 100644
--- a/crates/rome_js_formatter/tests/specs/prettier/typescript/arrow/comments.ts.snap
+++ b/crates/rome_js_formatter/tests/specs/prettier/typescript/arrow/comments.ts.snap
@@ -23,7 +23,7 @@ const fn2 = () => {
 ```diff
 --- Prettier
 +++ Rome
-@@ -1,9 +1,9 @@
+@@ -1,6 +1,6 @@
  const fn1 = () => {
    return;
 -}; /* foo */
@@ -31,11 +31,6 @@ const fn2 = () => {
  
  const fn2 = () => {
    return;
--};
--
-+}
- // foo
-+;
 ```
 
 # Output
@@ -47,9 +42,9 @@ const fn1 = () => {
 
 const fn2 = () => {
   return;
-}
+};
+
 // foo
-;
 ```
 
 
diff --git a/crates/rome_js_formatter/tests/specs/prettier/typescript/class-comment/class-implements.ts.snap b/crates/rome_js_formatter/tests/specs/prettier/typescript/class-comment/class-implements.ts.snap
deleted file mode 100644
index 879d379e679..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/typescript/class-comment/class-implements.ts.snap
+++ /dev/null
@@ -1,271 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-class a1 extends b // comment
-implements z
-{
-  constructor() {}
-}
-
-class a2 extends b implements z { // comment
-  constructor() {}
-}
-
-class a3 extends b
-implements
-// comment
-z,
-y {
-  constructor() {}
-}
-
-class a4 extends b
-implements z, // comment
-y {
-  constructor() {}
-}
-
-class a5 extends b  implements
-    z, // comment-z
-    y // comment-y
-    {
-  constructor() {}
-}
-
-class a6 extends b  implements
-// comment-z1
-    z, // comment-z2
-    // comment-y1
-    y // comment-y2
-    {
-  constructor() {}
-}
-
-class a7 extends b  implements
-// comment-z1
-    z, // comment-z2
-    // comment-y1
-    y // comment-y2
-         // comment-y3
-    {
-      //comment-body
-  constructor() {}
-}
-
-class a8 extends b // comment-b
- implements
-// comment-z1
-    z, // comment-z2
-    // comment-y1
-    y // comment-y2
-    {
-  constructor() {}
-}
-
-class a9 extends
-// comment-b1
-b // comment-b2
-// comment-b3
- implements
-// comment-z1
-    z, // comment-z2
-    // comment-y1
-    y // comment-y2
-    {
-  constructor() {}
-}
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -12,8 +12,10 @@
- 
- class a3
-   extends b
--  // comment
--  implements z, y
-+  implements
-+    // comment
-+    z,
-+    y
- {
-   constructor() {}
- }
-@@ -31,60 +33,56 @@
-   extends b
-   implements
-     z, // comment-z
--    y
-+    y // comment-y
- {
--  // comment-y
-   constructor() {}
- }
- 
- class a6
-   extends b
--  // comment-z1
-   implements
-+    // comment-z1
-     z, // comment-z2
-     // comment-y1
--    y
-+    y // comment-y2
- {
--  // comment-y2
-   constructor() {}
- }
- 
- class a7
-   extends b
--  // comment-z1
-   implements
-+    // comment-z1
-     z, // comment-z2
-     // comment-y1
--    y
-+    y // comment-y2
-+// comment-y3
- {
--  // comment-y2
--  // comment-y3
-   //comment-body
-   constructor() {}
- }
- 
- class a8
-   extends b // comment-b
--  // comment-z1
-   implements
-+    // comment-z1
-     z, // comment-z2
-     // comment-y1
--    y
-+    y // comment-y2
- {
--  // comment-y2
-   constructor() {}
- }
- 
- class a9
-+  extends
-   // comment-b1
--  extends b // comment-b2
-+  b // comment-b2
-   // comment-b3
--  // comment-z1
-   implements
-+    // comment-z1
-     z, // comment-z2
-     // comment-y1
--    y
-+    y // comment-y2
- {
--  // comment-y2
-   constructor() {}
- }
-```
-
-# Output
-
-```js
-class a1
-  extends b // comment
-  implements z
-{
-  constructor() {}
-}
-
-class a2 extends b implements z {
-  // comment
-  constructor() {}
-}
-
-class a3
-  extends b
-  implements
-    // comment
-    z,
-    y
-{
-  constructor() {}
-}
-
-class a4
-  extends b
-  implements
-    z, // comment
-    y
-{
-  constructor() {}
-}
-
-class a5
-  extends b
-  implements
-    z, // comment-z
-    y // comment-y
-{
-  constructor() {}
-}
-
-class a6
-  extends b
-  implements
-    // comment-z1
-    z, // comment-z2
-    // comment-y1
-    y // comment-y2
-{
-  constructor() {}
-}
-
-class a7
-  extends b
-  implements
-    // comment-z1
-    z, // comment-z2
-    // comment-y1
-    y // comment-y2
-// comment-y3
-{
-  //comment-body
-  constructor() {}
-}
-
-class a8
-  extends b // comment-b
-  implements
-    // comment-z1
-    z, // comment-z2
-    // comment-y1
-    y // comment-y2
-{
-  constructor() {}
-}
-
-class a9
-  extends
-  // comment-b1
-  b // comment-b2
-  // comment-b3
-  implements
-    // comment-z1
-    z, // comment-z2
-    // comment-y1
-    y // comment-y2
-{
-  constructor() {}
-}
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/typescript/class-comment/declare.ts.snap b/crates/rome_js_formatter/tests/specs/prettier/typescript/class-comment/declare.ts.snap
deleted file mode 100644
index 41c46755a99..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/typescript/class-comment/declare.ts.snap
+++ /dev/null
@@ -1,65 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-declare class a  // 1
-  // extends b   // 2
-  implements z,x // 3
-{
-  doo:boolean
-}
-
-declare class A1<T> // 1
-// 2
-extends B<T> // 3
-{}
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -1,13 +1,12 @@
- declare class a // 1
-   // extends b   // 2
--  implements z, x
-+  implements
-+    z,
-+    x // 3
- {
--  // 3
-   doo: boolean;
- }
- 
- declare class A1<T> // 1
-   // 2
--  extends B<T> {
--  // 3
--}
-+  extends B<T> {} // 3
-```
-
-# Output
-
-```js
-declare class a // 1
-  // extends b   // 2
-  implements
-    z,
-    x // 3
-{
-  doo: boolean;
-}
-
-declare class A1<T> // 1
-  // 2
-  extends B<T> {} // 3
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/typescript/class/extends_implements.ts.snap b/crates/rome_js_formatter/tests/specs/prettier/typescript/class/extends_implements.ts.snap
deleted file mode 100644
index a7cc4ca8777..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/typescript/class/extends_implements.ts.snap
+++ /dev/null
@@ -1,188 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-class Class extends AbstractClass implements Interface1, Interface2, Interface3, Interface4 {}
-
-class ExtendsAbstractClassAndImplementsInterfaces1 extends AbstractClass
-  implements Interface1, Interface2, Interface3, Interface4 {}
-
-class ExtendsAbstractClassAndImplementsInterfaces2
-  extends AAAAAAAAAAAAAAbstractClass
-  implements Interface1, Interface2, Interface3, Interface4 {}
-
-class ExtendsAbstractClassAndImplementsInterfaces3
-  extends AAAAAAAAAAAAAAbstractClass
-  implements
-    Interface1,
-    Interface2,
-    Interface3,
-    Interface4,
-    Interface5,
-    Interface6,
-    Interface7,
-    Interface8 {}
-
-class ExtendsAbstractClassAndImplementsInterfaces4
-  extends AAAAAAAAAAAAAAbstractClass<Type1, Type2, Type3, Type4, Type5, Type6, Type7> {}
-
-class ExtendsAbstractClassAndImplementsInterfaces5
-  extends AAAAAAAAAAAAAAbstractClass<Type1, Type2, Type3, Type4, Type5, Type6, Type7>
-  implements
-    Interface1,
-    Interface2,
-    Interface3,
-    Interface4,
-    Interface5,
-    Interface6,
-    Interface7,
-    Interface8 {}
-
-class ImplementsInterfaceAndExtendsAbstractClass1<Foo>
-  extends FOOOOOOOOOOOOOOOOO
-  implements FOOOOOOOOOOOOOOOOO, BARRRRRRRRRR {}
-
-class Foo<FOOOOOOOOOOOOOOOOOOOOOOOOOOO, FOOOOOOOOOOOOOOOOOOOOOOOOOOO> implements Foo {}
-
-class ImplementsInterfaceAndExtendsAbstractClass2<
-    TypeArgumentNumberOne,
-    TypeArgumentNumberTwo,
-    TypeArgumentNumberThree
-  >
-   extends FOOOOOOOOOOOOOOOOOO implements BaseInterface {}
-
-class ImplementsInterfaceClass1<
-    TypeArgumentNumberOne,
-    TypeArgumentNumberTwo,
-    TypeArgumentNumberThree
-  >
-    implements BaseInterface {}
-
-class ImplementsInterfaceClassWithComments1<
-    TypeArgumentNumberOne,
-    TypeArgumentNumberTwo,
-    TypeArgumentNumberThree
-  > // comments
-    implements BaseInterface {}
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -68,10 +68,11 @@
-   implements BaseInterface {}
- 
- class ImplementsInterfaceClass1<
--  TypeArgumentNumberOne,
--  TypeArgumentNumberTwo,
--  TypeArgumentNumberThree,
--> implements BaseInterface {}
-+    TypeArgumentNumberOne,
-+    TypeArgumentNumberTwo,
-+    TypeArgumentNumberThree,
-+  >
-+  implements BaseInterface {}
- 
- class ImplementsInterfaceClassWithComments1<
-     TypeArgumentNumberOne,
-```
-
-# Output
-
-```js
-class Class
-  extends AbstractClass
-  implements Interface1, Interface2, Interface3, Interface4 {}
-
-class ExtendsAbstractClassAndImplementsInterfaces1
-  extends AbstractClass
-  implements Interface1, Interface2, Interface3, Interface4 {}
-
-class ExtendsAbstractClassAndImplementsInterfaces2
-  extends AAAAAAAAAAAAAAbstractClass
-  implements Interface1, Interface2, Interface3, Interface4 {}
-
-class ExtendsAbstractClassAndImplementsInterfaces3
-  extends AAAAAAAAAAAAAAbstractClass
-  implements
-    Interface1,
-    Interface2,
-    Interface3,
-    Interface4,
-    Interface5,
-    Interface6,
-    Interface7,
-    Interface8 {}
-
-class ExtendsAbstractClassAndImplementsInterfaces4 extends AAAAAAAAAAAAAAbstractClass<
-  Type1,
-  Type2,
-  Type3,
-  Type4,
-  Type5,
-  Type6,
-  Type7
-> {}
-
-class ExtendsAbstractClassAndImplementsInterfaces5
-  extends AAAAAAAAAAAAAAbstractClass<
-    Type1,
-    Type2,
-    Type3,
-    Type4,
-    Type5,
-    Type6,
-    Type7
-  >
-  implements
-    Interface1,
-    Interface2,
-    Interface3,
-    Interface4,
-    Interface5,
-    Interface6,
-    Interface7,
-    Interface8 {}
-
-class ImplementsInterfaceAndExtendsAbstractClass1<Foo>
-  extends FOOOOOOOOOOOOOOOOO
-  implements FOOOOOOOOOOOOOOOOO, BARRRRRRRRRR {}
-
-class Foo<FOOOOOOOOOOOOOOOOOOOOOOOOOOO, FOOOOOOOOOOOOOOOOOOOOOOOOOOO>
-  implements Foo {}
-
-class ImplementsInterfaceAndExtendsAbstractClass2<
-    TypeArgumentNumberOne,
-    TypeArgumentNumberTwo,
-    TypeArgumentNumberThree,
-  >
-  extends FOOOOOOOOOOOOOOOOOO
-  implements BaseInterface {}
-
-class ImplementsInterfaceClass1<
-    TypeArgumentNumberOne,
-    TypeArgumentNumberTwo,
-    TypeArgumentNumberThree,
-  >
-  implements BaseInterface {}
-
-class ImplementsInterfaceClassWithComments1<
-    TypeArgumentNumberOne,
-    TypeArgumentNumberTwo,
-    TypeArgumentNumberThree,
-  > // comments
-  implements BaseInterface {}
-```
-
-
-# Lines exceeding max width of 80 characters
-```
-   25: class ExtendsAbstractClassAndImplementsInterfaces4 extends AAAAAAAAAAAAAAbstractClass<
-```
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/typescript/class/generics.ts.snap b/crates/rome_js_formatter/tests/specs/prettier/typescript/class/generics.ts.snap
deleted file mode 100644
index d91ddcf9d4d..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/typescript/class/generics.ts.snap
+++ /dev/null
@@ -1,52 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-class<T> implements Map<T> {}
-
-interface AudioBufferList {
-	mBuffers: interop.Reference<any /*AudioBuffer*/>;
-}
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -1,5 +1,5 @@
- class<T> implements Map<T> {}
- 
- interface AudioBufferList {
--  mBuffers: interop.Reference<any /*AudioBuffer*/>;
-+  mBuffers: interop.Reference<any /*AudioBuffer*/ >;
- }
-```
-
-# Output
-
-```js
-class<T> implements Map<T> {}
-
-interface AudioBufferList {
-  mBuffers: interop.Reference<any /*AudioBuffer*/ >;
-}
-```
-
-
-# Errors
-```
-error[SyntaxError]: class declarations must have a name
-  ┌─ generics.ts:1:1
-  │
-1 │ class<T> implements Map<T> {}
-  │ ^^^^^
-
-
-```
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/typescript/comments/after_jsx_generic.ts.snap b/crates/rome_js_formatter/tests/specs/prettier/typescript/comments/after_jsx_generic.ts.snap
deleted file mode 100644
index 36413b8d1b1..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/typescript/comments/after_jsx_generic.ts.snap
+++ /dev/null
@@ -1,93 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-let comp = (
-  <>
-    <Component<number> /* comment1 */></Component>
-    <Component<number> foo /* comment2 */></Component>
-    <Component<number> /* comment3 */ bar></Component>
-    <Component<number> foo /* comment4 */ bar></Component>
-
-    <Component<number>
-      // comment5
-    ></Component>
-    <Component<number>
-      foo
-      // comment6
-    ></Component>
-    <Component<number>
-      // comment7
-      foo
-    ></Component>
-    <Component<number>
-      foo
-      // comment8
-      bar
-    ></Component>
-  </>
-);
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -1,7 +1,7 @@
- let comp = (
-   <>
--    <Component<number> /* comment1 */></Component>
--    <Component<number> foo /* comment2 */></Component>
-+    <Component<number> /* comment1 */ ></Component>
-+    <Component<number> foo /* comment2 */ ></Component>
-     <Component<number> /* comment3 */ bar></Component>
-     <Component<number> foo /* comment4 */ bar></Component>
- 
-@@ -10,7 +10,7 @@
-     ></Component>
-     <Component<number>
-       foo
--      // comment6
-+    // comment6
-     ></Component>
-     <Component<number>
-       // comment7
-```
-
-# Output
-
-```js
-let comp = (
-  <>
-    <Component<number> /* comment1 */ ></Component>
-    <Component<number> foo /* comment2 */ ></Component>
-    <Component<number> /* comment3 */ bar></Component>
-    <Component<number> foo /* comment4 */ bar></Component>
-
-    <Component<number>
-    // comment5
-    ></Component>
-    <Component<number>
-      foo
-    // comment6
-    ></Component>
-    <Component<number>
-      // comment7
-      foo
-    ></Component>
-    <Component<number>
-      foo
-      // comment8
-      bar
-    ></Component>
-  </>
-);
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/typescript/comments/mapped_types.ts.snap b/crates/rome_js_formatter/tests/specs/prettier/typescript/comments/mapped_types.ts.snap
index 3ab2cc6ed58..9cdf5d2b939 100644
--- a/crates/rome_js_formatter/tests/specs/prettier/typescript/comments/mapped_types.ts.snap
+++ b/crates/rome_js_formatter/tests/specs/prettier/typescript/comments/mapped_types.ts.snap
@@ -1,5 +1,7 @@
 ---
 source: crates/rome_js_formatter/tests/prettier_tests.rs
+info:
+  test_file: typescript/comments/mapped_types.ts
 ---
 
 # Input
@@ -53,7 +55,7 @@ type M = { [m in M] /* commentG */: string }
 ```diff
 --- Prettier
 +++ Rome
-@@ -24,17 +24,30 @@
+@@ -24,7 +24,7 @@
  };
  
  type G = {
@@ -61,36 +63,13 @@ type M = { [m in M] /* commentG */: string }
 +  [g in G] /* commentG */ : string;
  };
  
--type H = { [/* commentH */ h in H]: string };
-+type H = {
-+  /* commentH */
-+  [h in H]: string;
-+};
+ type H = { [/* commentH */ h in H]: string };
+@@ -37,4 +37,4 @@
  
--type I = { [/* commentI */ i in I]: string };
-+type I = {
-+  [/* commentI */ i in I]: string;
-+};
- 
--type J = { [j /* commentJ */ in J]: string };
-+type J = {
-+  [j /* commentJ */ in J]: string;
-+};
- 
--type K = { [k in /* commentK */ K]: string };
-+type K = {
-+  [k in /* commentK */ K]: string;
-+};
- 
--type L = { [l in L /* commentL */]: string };
-+type L = {
-+  [l in L /* commentL */]: string;
-+};
+ type L = { [l in L /* commentL */]: string };
  
 -type M = { [m in M /* commentG */]: string };
-+type M = {
-+  [m in M] /* commentG */ : string;
-+};
++type M = { [m in M] /* commentG */ : string };
 ```
 
 # Output
@@ -125,30 +104,17 @@ type G = {
   [g in G] /* commentG */ : string;
 };
 
-type H = {
-  /* commentH */
-  [h in H]: string;
-};
+type H = { [/* commentH */ h in H]: string };
 
-type I = {
-  [/* commentI */ i in I]: string;
-};
+type I = { [/* commentI */ i in I]: string };
 
-type J = {
-  [j /* commentJ */ in J]: string;
-};
+type J = { [j /* commentJ */ in J]: string };
 
-type K = {
-  [k in /* commentK */ K]: string;
-};
+type K = { [k in /* commentK */ K]: string };
 
-type L = {
-  [l in L /* commentL */]: string;
-};
+type L = { [l in L /* commentL */]: string };
 
-type M = {
-  [m in M] /* commentG */ : string;
-};
+type M = { [m in M] /* commentG */ : string };
 ```
 
 
diff --git a/crates/rome_js_formatter/tests/specs/prettier/typescript/comments/method_types.ts.snap b/crates/rome_js_formatter/tests/specs/prettier/typescript/comments/method_types.ts.snap
index 458914df22c..e5a94a3b79d 100644
--- a/crates/rome_js_formatter/tests/specs/prettier/typescript/comments/method_types.ts.snap
+++ b/crates/rome_js_formatter/tests/specs/prettier/typescript/comments/method_types.ts.snap
@@ -1,5 +1,7 @@
 ---
 source: crates/rome_js_formatter/tests/prettier_tests.rs
+info:
+  test_file: typescript/comments/method_types.ts
 ---
 
 # Input
@@ -52,25 +54,21 @@ abstract class Test {
 ```diff
 --- Prettier
 +++ Rome
-@@ -1,11 +1,13 @@
+@@ -1,11 +1,11 @@
  interface foo1 {
--  bar3 /* foo */(/* baz */); // bat
+   bar3 /* foo */(/* baz */); // bat
 -  bar /* foo */ /* bar */?(/* baz */) /* bat */;
--  bar2 /* foo */(/* baz */) /* bat */;
-+  bar3 /* foo */ (
-+    /* baz */
-+  ); // bat
-+  bar /* foo */ ? /* bar */ (/* baz */) /* bat */;
-+  bar2 /* foo */ (/* baz */) /* bat */;
++  bar /* foo */?/* bar */ (/* baz */) /* bat */;
+   bar2 /* foo */(/* baz */) /* bat */;
  }
  
  interface foo2 {
 -  bar /* foo */?(/* bar */ bar: /* baz */ string): /* bat */ string;
-+  bar /* foo */ ? /* bar */ (bar: /* baz */ string): /* bat */ string;
++  bar /* foo */?/* bar */ (bar: /* baz */ string): /* bat */ string;
  }
  
  interface foo3 {
-@@ -17,23 +19,23 @@
+@@ -17,20 +17,20 @@
  }
  
  interface foo5 {
@@ -96,27 +94,20 @@ abstract class Test {
 +let foo10: new /* foo */ (a: /* bar */ string) /* baz */ => string;
  
  abstract class Test {
--  abstract foo12 /* foo */(a: /* bar */ string): /* baz */ void;
-+  abstract foo12 /* foo */ (a: /* bar */ string): /* baz */ void;
- 
--  abstract foo13 /* foo */(/* bar */); /* baz */
-+  abstract foo13 /* foo */ (/* bar */) /* baz */;
- }
+   abstract foo12 /* foo */(a: /* bar */ string): /* baz */ void;
 ```
 
 # Output
 
 ```js
 interface foo1 {
-  bar3 /* foo */ (
-    /* baz */
-  ); // bat
-  bar /* foo */ ? /* bar */ (/* baz */) /* bat */;
-  bar2 /* foo */ (/* baz */) /* bat */;
+  bar3 /* foo */(/* baz */); // bat
+  bar /* foo */?/* bar */ (/* baz */) /* bat */;
+  bar2 /* foo */(/* baz */) /* bat */;
 }
 
 interface foo2 {
-  bar /* foo */ ? /* bar */ (bar: /* baz */ string): /* bat */ string;
+  bar /* foo */?/* bar */ (bar: /* baz */ string): /* bat */ string;
 }
 
 interface foo3 {
@@ -144,9 +135,9 @@ let foo9: new /* foo */ (/* bar */) /* baz */ => string;
 let foo10: new /* foo */ (a: /* bar */ string) /* baz */ => string;
 
 abstract class Test {
-  abstract foo12 /* foo */ (a: /* bar */ string): /* baz */ void;
+  abstract foo12 /* foo */(a: /* bar */ string): /* baz */ void;
 
-  abstract foo13 /* foo */ (/* bar */) /* baz */;
+  abstract foo13 /* foo */(/* bar */); /* baz */
 }
 ```
 
diff --git a/crates/rome_js_formatter/tests/specs/prettier/typescript/comments/methods.ts.snap b/crates/rome_js_formatter/tests/specs/prettier/typescript/comments/methods.ts.snap
deleted file mode 100644
index 198dd71b9bf..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/typescript/comments/methods.ts.snap
+++ /dev/null
@@ -1,131 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-export class Point {
-/**
- * Does something.
- */
-  foo() {}
-
-    /**
-     * Does something else.
-     */
-  bar() {}
-
-                /**
-                 * Does
-                 * something
-                 * much
-                 * better
-                 * than
-                 * the
-                 * rest.
-                 */
-  baz() {}
-
-      /**
-       * Buzz-Fizz.
-       * Note: This is indented too far.
-       */
-      fizzBuzz() {}
-
-      /**
-       * Turns the given string into pig-latin.
-       */
-              pigLatinize(value: string) {
-/**
- * This is a block comment inside of a method.
- */
-              }
-
-  /**
-        * One
- * Two
-   * Three
-* Four 
-   */
-  mismatchedIndentation() {}
-
-  inline /* foo*/ (/* bar */) /* baz */ {}
-
-  noBody(/* comment */ arg);
-}
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -43,7 +43,7 @@
-    */
-   mismatchedIndentation() {}
- 
--  inline /* foo*/(/* bar */) /* baz */ {}
-+  inline /* foo*/ (/* bar */) /* baz */ {}
- 
-   noBody(/* comment */ arg);
- }
-```
-
-# Output
-
-```js
-export class Point {
-  /**
-   * Does something.
-   */
-  foo() {}
-
-  /**
-   * Does something else.
-   */
-  bar() {}
-
-  /**
-   * Does
-   * something
-   * much
-   * better
-   * than
-   * the
-   * rest.
-   */
-  baz() {}
-
-  /**
-   * Buzz-Fizz.
-   * Note: This is indented too far.
-   */
-  fizzBuzz() {}
-
-  /**
-   * Turns the given string into pig-latin.
-   */
-  pigLatinize(value: string) {
-    /**
-     * This is a block comment inside of a method.
-     */
-  }
-
-  /**
-   * One
-   * Two
-   * Three
-   * Four
-   */
-  mismatchedIndentation() {}
-
-  inline /* foo*/ (/* bar */) /* baz */ {}
-
-  noBody(/* comment */ arg);
-}
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/typescript/comments/type-parameters.ts.snap b/crates/rome_js_formatter/tests/specs/prettier/typescript/comments/type-parameters.ts.snap
index b77ce3cf89b..372dde289a9 100644
--- a/crates/rome_js_formatter/tests/specs/prettier/typescript/comments/type-parameters.ts.snap
+++ b/crates/rome_js_formatter/tests/specs/prettier/typescript/comments/type-parameters.ts.snap
@@ -1,5 +1,7 @@
 ---
 source: crates/rome_js_formatter/tests/prettier_tests.rs
+info:
+  test_file: typescript/comments/type-parameters.ts
 ---
 
 # Input
@@ -42,53 +44,43 @@ type T = <
 ```diff
 --- Prettier
 +++ Rome
-@@ -1,18 +1,18 @@
--functionName<A /* A comment */>();
--const a: T</* comment */> = 1;
--functionName</* comment */>();
--function foo</* comment */>() {}
-+functionName<A /* A comment */ >();
-+const a: T< /* comment */ > = 1;
-+functionName< /* comment */ >();
-+function foo< /* comment */ >() {}
+@@ -3,7 +3,7 @@
+ functionName</* comment */>();
+ function foo</* comment */>() {}
  interface Foo {
 -  </* comment */>(arg): any;
-+  < /* comment */ >(arg): any;
++ </* comment */>(arg): any;
  }
--type T = </* comment */>(arg) => any;
-+type T = < /* comment */ >(arg) => any;
+ type T = </* comment */>(arg) => any;
  
- functionName<A>(); // comment
- const a: T<
--  // comment
-+// comment
- > = 1;
- functionName<
--  // comment
-+// comment
- >();
- function foo<
+@@ -26,6 +26,4 @@
+ }
+ type T = <
    // comment
+->(
+-  arg,
+-) => any;
++>(arg) => any;
 ```
 
 # Output
 
 ```js
-functionName<A /* A comment */ >();
-const a: T< /* comment */ > = 1;
-functionName< /* comment */ >();
-function foo< /* comment */ >() {}
+functionName<A /* A comment */>();
+const a: T</* comment */> = 1;
+functionName</* comment */>();
+function foo</* comment */>() {}
 interface Foo {
-  < /* comment */ >(arg): any;
+ </* comment */>(arg): any;
 }
-type T = < /* comment */ >(arg) => any;
+type T = </* comment */>(arg) => any;
 
 functionName<A>(); // comment
 const a: T<
-// comment
+  // comment
 > = 1;
 functionName<
-// comment
+  // comment
 >();
 function foo<
   // comment
@@ -102,9 +94,7 @@ interface Foo {
 }
 type T = <
   // comment
->(
-  arg,
-) => any;
+>(arg) => any;
 ```
 
 
diff --git a/crates/rome_js_formatter/tests/specs/prettier/typescript/comments/union.ts.snap b/crates/rome_js_formatter/tests/specs/prettier/typescript/comments/union.ts.snap
deleted file mode 100644
index 9159b8f00eb..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/typescript/comments/union.ts.snap
+++ /dev/null
@@ -1,85 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-type UploadState<E, EM, D>
-  // The upload hasnt begun yet
-  = {type: "Not_begun"}
-  // The upload timed out
-  | {type: "Timed_out"}
-  // Failed somewhere on the line
-  | {type: "Failed", error: E, errorMsg: EM}
-  // Uploading to aws3 and CreatePostMutation succeeded
-  | {type: "Success", data: D};
-
-type UploadState2<E, EM, D>
-  // The upload hasnt begun yet
-  = A
-  // The upload timed out
-  | B
-  // Failed somewhere on the line
-  | C
-  // Uploading to aws3 and CreatePostMutation succeeded
-  | D;
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -1,5 +1,6 @@
--type UploadState<E, EM, D> =
--  // The upload hasnt begun yet
-+type UploadState<E, EM, D>
-+// The upload hasnt begun yet
-+=
-   | { type: "Not_begun" }
-   // The upload timed out
-   | { type: "Timed_out" }
-@@ -8,8 +9,9 @@
-   // Uploading to aws3 and CreatePostMutation succeeded
-   | { type: "Success"; data: D };
- 
--type UploadState2<E, EM, D> =
--  // The upload hasnt begun yet
-+type UploadState2<E, EM, D>
-+// The upload hasnt begun yet
-+=
-   | A
-   // The upload timed out
-   | B
-```
-
-# Output
-
-```js
-type UploadState<E, EM, D>
-// The upload hasnt begun yet
-=
-  | { type: "Not_begun" }
-  // The upload timed out
-  | { type: "Timed_out" }
-  // Failed somewhere on the line
-  | { type: "Failed"; error: E; errorMsg: EM }
-  // Uploading to aws3 and CreatePostMutation succeeded
-  | { type: "Success"; data: D };
-
-type UploadState2<E, EM, D>
-// The upload hasnt begun yet
-=
-  | A
-  // The upload timed out
-  | B
-  // Failed somewhere on the line
-  | C
-  // Uploading to aws3 and CreatePostMutation succeeded
-  | D;
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/typescript/conditional-types/comments.ts.snap b/crates/rome_js_formatter/tests/specs/prettier/typescript/conditional-types/comments.ts.snap
deleted file mode 100644
index 738b3642f4b..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/typescript/conditional-types/comments.ts.snap
+++ /dev/null
@@ -1,218 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-type A = B extends T
-  ? // comment
-    foo
-  : bar;
-
-type A = B extends test /* comment
-  comment
-      comment
-*/
-  ? foo
-  : bar;
-
-type T = test extends B
-  ? /* comment
-          comment
-    comment
-          comment
-  */
-    foo
-  : bar;
-
-type T = test extends B
-  ? /* comment
-       comment
-       comment
-       comment
-    */
-    foo
-  : test extends B
-  ? /* comment
-  comment
-    comment */
-    foo
-  : bar;
-
-type T = test extends B
-  ? /* comment */
-    foo
-  : bar;
-
-type T = test extends B
-  ? foo
-  : /* comment
-         comment
-     comment
-           comment
-    */
-  bar;
-
-type T = test extends B
-  ? foo
-  : /* comment
-         comment
-     comment
-           comment
-    */
-  test extends B
-  ? foo
-  : /* comment
-  comment
-    comment
-   */
-    bar;
-
-type T = test extends B
-  ? foo
-  : /* comment */
-  bar;
-
-type T = test extends B ? test extends B /* c
-c */? foo : bar : bar;
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -1,6 +1,5 @@
- type A = B extends T
--  ? // comment
--    foo
-+  ? foo // comment
-   : bar;
- 
- type A = B extends test /* comment
-@@ -15,8 +14,7 @@
-           comment
-     comment
-           comment
--  */
--    foo
-+  */ foo
-   : bar;
- 
- type T = test extends B
-@@ -24,13 +22,11 @@
-        comment
-        comment
-        comment
--    */
--    foo
-+    */ foo
-   : test extends B
-   ? /* comment
-   comment
--    comment */
--    foo
-+    comment */ foo
-   : bar;
- 
- type T = test extends B ? /* comment */ foo : bar;
-@@ -41,8 +37,7 @@
-          comment
-      comment
-            comment
--    */
--    bar;
-+    */ bar;
- 
- type T = test extends B
-   ? foo
-@@ -50,14 +45,12 @@
-          comment
-      comment
-            comment
--    */
--  test extends B
-+    */ test extends B
-   ? foo
-   : /* comment
-   comment
-     comment
--   */
--    bar;
-+   */ bar;
- 
- type T = test extends B ? foo : /* comment */ bar;
- 
-```
-
-# Output
-
-```js
-type A = B extends T
-  ? foo // comment
-  : bar;
-
-type A = B extends test /* comment
-  comment
-      comment
-*/
-  ? foo
-  : bar;
-
-type T = test extends B
-  ? /* comment
-          comment
-    comment
-          comment
-  */ foo
-  : bar;
-
-type T = test extends B
-  ? /* comment
-       comment
-       comment
-       comment
-    */ foo
-  : test extends B
-  ? /* comment
-  comment
-    comment */ foo
-  : bar;
-
-type T = test extends B ? /* comment */ foo : bar;
-
-type T = test extends B
-  ? foo
-  : /* comment
-         comment
-     comment
-           comment
-    */ bar;
-
-type T = test extends B
-  ? foo
-  : /* comment
-         comment
-     comment
-           comment
-    */ test extends B
-  ? foo
-  : /* comment
-  comment
-    comment
-   */ bar;
-
-type T = test extends B ? foo : /* comment */ bar;
-
-type T = test extends B
-  ? test extends B /* c
-c */
-    ? foo
-    : bar
-  : bar;
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/typescript/conformance/types/mappedType/mappedType.ts.snap b/crates/rome_js_formatter/tests/specs/prettier/typescript/conformance/types/mappedType/mappedType.ts.snap
deleted file mode 100644
index 5daf2533ae2..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/typescript/conformance/types/mappedType/mappedType.ts.snap
+++ /dev/null
@@ -1,37 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-type Keys = 'option1' | 'option2';
-type Flags = { [K in Keys]: boolean };
-
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -1,2 +1,4 @@
- type Keys = "option1" | "option2";
--type Flags = { [K in Keys]: boolean };
-+type Flags = {
-+  [K in Keys]: boolean;
-+};
-```
-
-# Output
-
-```js
-type Keys = "option1" | "option2";
-type Flags = {
-  [K in Keys]: boolean;
-};
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/typescript/custom/typeParameters/variables.ts.snap b/crates/rome_js_formatter/tests/specs/prettier/typescript/custom/typeParameters/variables.ts.snap
index 657861d47b1..57957fc60a4 100644
--- a/crates/rome_js_formatter/tests/specs/prettier/typescript/custom/typeParameters/variables.ts.snap
+++ b/crates/rome_js_formatter/tests/specs/prettier/typescript/custom/typeParameters/variables.ts.snap
@@ -34,23 +34,8 @@ const fooooooooooooooo: SomeThing<string["anchor"]> = looooooooooooooooooooooooo
 ```diff
 --- Prettier
 +++ Rome
-@@ -1,18 +1,20 @@
- const foo: SomeThing<boolean> = func();
- const bar: SomeThing<boolean, boolean> = func();
--const fooo: SomeThing<{ [P in "x" | "y"]: number }> = func();
-+const fooo: SomeThing<{
-+  [P in "x" | "y"]: number;
-+}> = func();
- const baar: SomeThing<K extends T ? G : S> = func();
- const fooooooooooooooo: SomeThing<boolean> =
+@@ -10,9 +10,8 @@
    looooooooooooooooooooooooooooooongNameFunc();
- const baaaaaaaaaaaaaaaaaaaaar: SomeThing<boolean, boolean> =
-   looooooooooooooooooooooooooooooongNameFunc();
--const baaaaaaaaaaaaaaar: SomeThing<{ [P in "x" | "y"]: number }> =
--  looooooooooooooooooooooooooooooongNameFunc();
-+const baaaaaaaaaaaaaaar: SomeThing<{
-+  [P in "x" | "y"]: number;
-+}> = looooooooooooooooooooooooooooooongNameFunc();
  const baaaaaaaaaaaaaaaar: SomeThing<K extends T ? G : S> =
    looooooooooooooooooooooooooooooongNameFunc();
 -const isAnySuccessfulAttempt$: Observable<boolean> = this._quizService
@@ -68,17 +53,14 @@ const fooooooooooooooo: SomeThing<string["anchor"]> = looooooooooooooooooooooooo
 ```js
 const foo: SomeThing<boolean> = func();
 const bar: SomeThing<boolean, boolean> = func();
-const fooo: SomeThing<{
-  [P in "x" | "y"]: number;
-}> = func();
+const fooo: SomeThing<{ [P in "x" | "y"]: number }> = func();
 const baar: SomeThing<K extends T ? G : S> = func();
 const fooooooooooooooo: SomeThing<boolean> =
   looooooooooooooooooooooooooooooongNameFunc();
 const baaaaaaaaaaaaaaaaaaaaar: SomeThing<boolean, boolean> =
   looooooooooooooooooooooooooooooongNameFunc();
-const baaaaaaaaaaaaaaar: SomeThing<{
-  [P in "x" | "y"]: number;
-}> = looooooooooooooooooooooooooooooongNameFunc();
+const baaaaaaaaaaaaaaar: SomeThing<{ [P in "x" | "y"]: number }> =
+  looooooooooooooooooooooooooooooongNameFunc();
 const baaaaaaaaaaaaaaaar: SomeThing<K extends T ? G : S> =
   looooooooooooooooooooooooooooooongNameFunc();
 const isAnySuccessfulAttempt$: Observable<boolean> =
diff --git a/crates/rome_js_formatter/tests/specs/prettier/typescript/decorators/decorators.ts.snap b/crates/rome_js_formatter/tests/specs/prettier/typescript/decorators/decorators.ts.snap
index 54455e67c94..9cf719c4911 100644
--- a/crates/rome_js_formatter/tests/specs/prettier/typescript/decorators/decorators.ts.snap
+++ b/crates/rome_js_formatter/tests/specs/prettier/typescript/decorators/decorators.ts.snap
@@ -1,5 +1,7 @@
 ---
 source: crates/rome_js_formatter/tests/prettier_tests.rs
+info:
+  test_file: typescript/decorators/decorators.ts
 ---
 
 # Input
@@ -90,7 +92,15 @@ class Class6 {
 ```diff
 --- Prettier
 +++ Rome
-@@ -6,7 +6,7 @@
+@@ -1,12 +1,14 @@
+ export class TestTextFileService {
+-  constructor(@ILifecycleService lifecycleService) {}
++  constructor(
++    @ILifecycleService lifecycleService,
++  ) {}
+ }
+ 
+ @commonEditorContribution
  export class TabCompletionController {}
  
  @Component({
@@ -99,26 +109,31 @@ class Class6 {
  })
  class AngularComponent {
    @Input() myInput: string;
-@@ -44,6 +44,7 @@
- class Class4 {
-   method(
-     param1,
-+
-     @Decorator
-     { prop1, prop2 }: Type,
-   ) {}
-@@ -54,8 +55,14 @@
+@@ -50,12 +52,24 @@
+ }
+ 
+ class Class5 {
+-  method(@Decorator { prop1 }: Type) {}
++  method(
++    @Decorator { prop1 }: Type,
++  ) {}
  }
  
  class Class6 {
 -  method(@Decorator({}) { prop1 }: Type) {}
-   method(@Decorator({}) { prop1 }: Type) {}
+-  method(@Decorator({}) { prop1 }: Type) {}
+-  method(@Decorator([]) { prop1 }: Type) {}
 -  method(@Decorator([]) { prop1 }: Type) {}
 +  method(
++    @Decorator({}) { prop1 }: Type,
++  ) {}
++  method(
 +    @Decorator(
 +      {}) { prop1 }: Type,
 +  ) {}
-   method(@Decorator([]) { prop1 }: Type) {}
++  method(
++    @Decorator([]) { prop1 }: Type,
++  ) {}
 +  method(
 +    @Decorator(
 +      []) { prop1 }: Type,
@@ -130,7 +145,9 @@ class Class6 {
 
 ```js
 export class TestTextFileService {
-  constructor(@ILifecycleService lifecycleService) {}
+  constructor(
+    @ILifecycleService lifecycleService,
+  ) {}
 }
 
 @commonEditorContribution
@@ -175,23 +192,28 @@ class Class3 {
 class Class4 {
   method(
     param1,
-
     @Decorator
     { prop1, prop2 }: Type,
   ) {}
 }
 
 class Class5 {
-  method(@Decorator { prop1 }: Type) {}
+  method(
+    @Decorator { prop1 }: Type,
+  ) {}
 }
 
 class Class6 {
-  method(@Decorator({}) { prop1 }: Type) {}
+  method(
+    @Decorator({}) { prop1 }: Type,
+  ) {}
   method(
     @Decorator(
       {}) { prop1 }: Type,
   ) {}
-  method(@Decorator([]) { prop1 }: Type) {}
+  method(
+    @Decorator([]) { prop1 }: Type,
+  ) {}
   method(
     @Decorator(
       []) { prop1 }: Type,
diff --git a/crates/rome_js_formatter/tests/specs/prettier/typescript/decorators/inline-decorators.ts.snap b/crates/rome_js_formatter/tests/specs/prettier/typescript/decorators/inline-decorators.ts.snap
index d16230ec55f..aec46c2358e 100644
--- a/crates/rome_js_formatter/tests/specs/prettier/typescript/decorators/inline-decorators.ts.snap
+++ b/crates/rome_js_formatter/tests/specs/prettier/typescript/decorators/inline-decorators.ts.snap
@@ -1,5 +1,7 @@
 ---
 source: crates/rome_js_formatter/tests/prettier_tests.rs
+info:
+  test_file: typescript/decorators/inline-decorators.ts
 ---
 
 # Input
@@ -75,13 +77,12 @@ class MyContainerComponent {
    method1() {}
  
    @d1
-@@ -30,22 +30,20 @@
+@@ -30,22 +30,19 @@
    constructor(
      @d1 private x: number,
      @d2(foo) private y: number,
 -    @d3("foo") private z: number,
 +    @d3('foo') private z: number,
-+
      @d4({
 -      x: string,
 -    })
@@ -142,7 +143,6 @@ class Class3 {
     @d1 private x: number,
     @d2(foo) private y: number,
     @d3('foo') private z: number,
-
     @d4({
             x: string
         }) private a: string,
@@ -163,6 +163,6 @@ class MyContainerComponent {
 
 # Lines exceeding max width of 80 characters
 ```
-   48:   @ContentChildren(MyComponent) components: QueryListSomeBigName<MyComponentThat>;
+   47:   @ContentChildren(MyComponent) components: QueryListSomeBigName<MyComponentThat>;
 ```
 
diff --git a/crates/rome_js_formatter/tests/specs/prettier/typescript/error-recovery/generic.ts.snap b/crates/rome_js_formatter/tests/specs/prettier/typescript/error-recovery/generic.ts.snap
new file mode 100644
index 00000000000..ead5c7f144f
--- /dev/null
+++ b/crates/rome_js_formatter/tests/specs/prettier/typescript/error-recovery/generic.ts.snap
@@ -0,0 +1,145 @@
+---
+source: crates/rome_js_formatter/tests/prettier_tests.rs
+info:
+  test_file: typescript/error-recovery/generic.ts
+---
+
+# Input
+
+```js
+f1<>();
+
+new f2<>();
+
+function f3<>() {}
+
+class f4 {
+    constructor<>() {}
+}
+
+const f5 = function<>() {}
+
+interface f6<> {
+    test<>();
+}
+
+class f7<> {
+    test<>() {}
+}
+```
+
+
+# Prettier differences
+
+```diff
+--- Prettier
++++ Rome
+@@ -8,12 +8,12 @@
+   constructor<>() {}
+ }
+ 
+-const f5 = function <>() {};
++const f5 = function<>() {}
+ 
+ interface f6<> {
+-  test<>();
++    test<>();
+ }
+ 
+ class f7<> {
+-  test<>() {}
++    test<>() {}
+ }
+```
+
+# Output
+
+```js
+f1<>();
+
+new f2<>();
+
+function f3<>() {}
+
+class f4 {
+  constructor<>() {}
+}
+
+const f5 = function<>() {}
+
+interface f6<> {
+    test<>();
+}
+
+class f7<> {
+    test<>() {}
+}
+```
+
+
+# Errors
+```
+error[SyntaxError]: expected a type parameter but instead found '>'
+  ┌─ generic.ts:1:4
+  │
+1 │ f1<>();
+  │    ^ Expected a type parameter here
+
+error[SyntaxError]: expected a type parameter but instead found '>'
+  ┌─ generic.ts:3:8
+  │
+3 │ new f2<>();
+  │        ^ Expected a type parameter here
+
+error[SyntaxError]: expected a type parameter but instead found '>'
+  ┌─ generic.ts:5:13
+  │
+5 │ function f3<>() {}
+  │             ^ Expected a type parameter here
+
+error[SyntaxError]: expected a type parameter but instead found '>'
+  ┌─ generic.ts:8:17
+  │
+8 │     constructor<>() {}
+  │                 ^ Expected a type parameter here
+
+error[SyntaxError]: constructors cannot have type parameters.
+  ┌─ generic.ts:8:16
+  │
+8 │     constructor<>() {}
+  │                ^^
+
+error[SyntaxError]: expected a type parameter but instead found '>'
+   ┌─ generic.ts:11:21
+   │
+11 │ const f5 = function<>() {}
+   │                     ^ Expected a type parameter here
+
+error[SyntaxError]: expected a type parameter but instead found '>'
+   ┌─ generic.ts:13:14
+   │
+13 │ interface f6<> {
+   │              ^ Expected a type parameter here
+
+error[SyntaxError]: expected a type parameter but instead found '>'
+   ┌─ generic.ts:14:10
+   │
+14 │     test<>();
+   │          ^ Expected a type parameter here
+
+error[SyntaxError]: expected a type parameter but instead found '>'
+   ┌─ generic.ts:17:10
+   │
+17 │ class f7<> {
+   │          ^ Expected a type parameter here
+
+error[SyntaxError]: expected a type parameter but instead found '>'
+   ┌─ generic.ts:18:10
+   │
+18 │     test<>() {}
+   │          ^ Expected a type parameter here
+
+
+```
+
+
diff --git a/crates/rome_js_formatter/tests/specs/prettier/typescript/export/comment.ts.snap b/crates/rome_js_formatter/tests/specs/prettier/typescript/export/comment.ts.snap
deleted file mode 100644
index cef2de770b9..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/typescript/export/comment.ts.snap
+++ /dev/null
@@ -1,32 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-export function match(): string /* the matching pattern */
-a
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -1,2 +1,2 @@
--export function match(): string; /* the matching pattern */
-+export function match(): string /* the matching pattern */;
- a;
-```
-
-# Output
-
-```js
-export function match(): string /* the matching pattern */;
-a;
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/typescript/interface2/break.ts.snap b/crates/rome_js_formatter/tests/specs/prettier/typescript/interface2/break.ts.snap
index 5104cc03914..bcd990ac239 100644
--- a/crates/rome_js_formatter/tests/specs/prettier/typescript/interface2/break.ts.snap
+++ b/crates/rome_js_formatter/tests/specs/prettier/typescript/interface2/break.ts.snap
@@ -104,39 +104,6 @@ export interface ExtendsLongOneWithGenerics extends Bar< SomeLongTypeSomeLongTyp
  }
  
  // Declare Interface Break
-@@ -68,14 +71,14 @@
- 
- interface ExtendsMany
-   extends ASingleGenericInterface<
--    Interface1,
--    Interface2,
--    Interface3,
--    Interface4,
--    Interface5,
--    Interface6,
--    Interface7
--  > {
-+      Interface1,
-+      Interface2,
-+      Interface3,
-+      Interface4,
-+      Interface5,
-+      Interface6,
-+      Interface7
-+    > {
-   x: string;
- }
- 
-@@ -97,6 +100,6 @@
- 
- export interface ExtendsLongOneWithGenerics
-   extends Bar<
--    SomeLongTypeSomeLongTypeSomeLongTypeSomeLongType,
--    ToBreakLineToBreakLineToBreakLine
--  > {}
-+      SomeLongTypeSomeLongTypeSomeLongTypeSomeLongType,
-+      ToBreakLineToBreakLineToBreakLine
-+    > {}
 ```
 
 # Output
@@ -215,14 +182,14 @@ interface ExtendsLarge
 
 interface ExtendsMany
   extends ASingleGenericInterface<
-      Interface1,
-      Interface2,
-      Interface3,
-      Interface4,
-      Interface5,
-      Interface6,
-      Interface7
-    > {
+    Interface1,
+    Interface2,
+    Interface3,
+    Interface4,
+    Interface5,
+    Interface6,
+    Interface7
+  > {
   x: string;
 }
 
@@ -244,9 +211,9 @@ interface ExtendsManyWithGenerics
 
 export interface ExtendsLongOneWithGenerics
   extends Bar<
-      SomeLongTypeSomeLongTypeSomeLongTypeSomeLongType,
-      ToBreakLineToBreakLineToBreakLine
-    > {}
+    SomeLongTypeSomeLongTypeSomeLongTypeSomeLongType,
+    ToBreakLineToBreakLineToBreakLine
+  > {}
 ```
 
 
diff --git a/crates/rome_js_formatter/tests/specs/prettier/typescript/interface2/comments.ts.snap b/crates/rome_js_formatter/tests/specs/prettier/typescript/interface2/comments.ts.snap
deleted file mode 100644
index 4eb6fdefd27..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/typescript/interface2/comments.ts.snap
+++ /dev/null
@@ -1,128 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-interface A1  // comment
-{  foo(): bar;}
-
-interface A2  // comment
-extends Base
-{  foo(): bar;}
-
-interface A3  // comment1
-extends Base  // comment2
-{  foo(): bar;}
-
-interface A4  // comment1
-extends Base  // comment2
-              // comment3
-{  foo(): bar;}
-
-interface A5  // comment1
-extends Base  // comment2
-              // comment3
-{             // comment4
-foo(): bar;}
-
-interface A6  // comment1
-extends Base  // comment2
-              // comment3
-{
-// comment4
-foo(): bar;}
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -15,24 +15,27 @@
- }
- 
- interface A4 // comment1
--  extends Base {
-+  extends Base
-+// comment3
-+{
-   // comment2
--  // comment3
-   foo(): bar;
- }
- 
- interface A5 // comment1
--  extends Base {
--  // comment2
--  // comment3
-+  extends Base
-+// comment3
-+{
-   // comment4
-+  // comment2
-   foo(): bar;
- }
- 
- interface A6 // comment1
--  extends Base {
-+  extends Base
-+// comment3
-+{
-   // comment2
--  // comment3
-   // comment4
-   foo(): bar;
- }
-```
-
-# Output
-
-```js
-interface A1 {
-  // comment
-  foo(): bar;
-}
-
-interface A2 // comment
-  extends Base {
-  foo(): bar;
-}
-
-interface A3 // comment1
-  extends Base {
-  // comment2
-  foo(): bar;
-}
-
-interface A4 // comment1
-  extends Base
-// comment3
-{
-  // comment2
-  foo(): bar;
-}
-
-interface A5 // comment1
-  extends Base
-// comment3
-{
-  // comment4
-  // comment2
-  foo(): bar;
-}
-
-interface A6 // comment1
-  extends Base
-// comment3
-{
-  // comment2
-  // comment4
-  foo(): bar;
-}
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/typescript/keyword-types/conditional-types.ts.snap b/crates/rome_js_formatter/tests/specs/prettier/typescript/keyword-types/conditional-types.ts.snap
deleted file mode 100644
index e1a8d4a8207..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/typescript/keyword-types/conditional-types.ts.snap
+++ /dev/null
@@ -1,56 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-export type UnwrappedResultRow<T> = {
-    [P in keyof T]: (
-        T[P] extends Req<infer a> ? (
-            a
-        ) : (
-            T[P] extends Opt<infer b> ? (
-                b
-            ) : (
-                // TEST
-                never
-            )
-        )
-    );
-};
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -3,6 +3,7 @@
-     ? a
-     : T[P] extends Opt<infer b>
-     ? b
--    : // TEST
-+    :
-+      // TEST
-       never;
- };
-```
-
-# Output
-
-```js
-export type UnwrappedResultRow<T> = {
-  [P in keyof T]: T[P] extends Req<infer a>
-    ? a
-    : T[P] extends Opt<infer b>
-    ? b
-    :
-      // TEST
-      never;
-};
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/typescript/keyword-types/keyword-types-with-parens-comments.ts.snap b/crates/rome_js_formatter/tests/specs/prettier/typescript/keyword-types/keyword-types-with-parens-comments.ts.snap
deleted file mode 100644
index d321dd2b756..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/typescript/keyword-types/keyword-types-with-parens-comments.ts.snap
+++ /dev/null
@@ -1,168 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-let foo: (
-    // comment
-    any
-);
-let foo: (
-    // comment
-    null
-);
-let foo: (
-    // comment
-    this
-);
-let foo: (
-    // comment
-    number
-);
-let foo: (
-    // comment
-    void
-);
-let foo: (
-    // comment
-    boolean
-);
-let foo: (
-    // comment
-    bigint
-);
-let foo: (
-    // comment
-    symbol
-);
-let foo: (
-    // comment
-    string
-);
-let foo: (
-    // comment
-    never
-);
-let foo: (
-    // comment
-    object
-);
-let foo: (
-    // comment
-    undefined
-);
-let foo: (
-    // comment
-    unknown
-);
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -1,26 +1,39 @@
--let foo: // comment
-+let foo:
-+// comment
- any;
--let foo: // comment
-+let foo:
-+// comment
- null;
--let foo: // comment
-+let foo:
-+// comment
- this;
--let foo: // comment
-+let foo:
-+// comment
- number;
--let foo: // comment
-+let foo:
-+// comment
- void;
--let foo: // comment
-+let foo:
-+// comment
- boolean;
--let foo: // comment
-+let foo:
-+// comment
- bigint;
--let foo: // comment
-+let foo:
-+// comment
- symbol;
--let foo: // comment
-+let foo:
-+// comment
- string;
--let foo: // comment
-+let foo:
-+// comment
- never;
--let foo: // comment
-+let foo:
-+// comment
- object;
--let foo: // comment
-+let foo:
-+// comment
- undefined;
--let foo: // comment
-+let foo:
-+// comment
- unknown;
-```
-
-# Output
-
-```js
-let foo:
-// comment
-any;
-let foo:
-// comment
-null;
-let foo:
-// comment
-this;
-let foo:
-// comment
-number;
-let foo:
-// comment
-void;
-let foo:
-// comment
-boolean;
-let foo:
-// comment
-bigint;
-let foo:
-// comment
-symbol;
-let foo:
-// comment
-string;
-let foo:
-// comment
-never;
-let foo:
-// comment
-object;
-let foo:
-// comment
-undefined;
-let foo:
-// comment
-unknown;
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/typescript/keywords/keywords.ts.snap b/crates/rome_js_formatter/tests/specs/prettier/typescript/keywords/keywords.ts.snap
index 89e4c57740a..cc98ca3000f 100644
--- a/crates/rome_js_formatter/tests/specs/prettier/typescript/keywords/keywords.ts.snap
+++ b/crates/rome_js_formatter/tests/specs/prettier/typescript/keywords/keywords.ts.snap
@@ -1,5 +1,7 @@
 ---
 source: crates/rome_js_formatter/tests/prettier_tests.rs
+info:
+  test_file: typescript/keywords/keywords.ts
 ---
 
 # Input
@@ -65,7 +67,7 @@ module YYY4 {
  
    // Apparently this parses :P
 -  export private public protected static readonly abstract async enum X {}
-+    export
++  export
 +  private
 +  public
 +  protected
@@ -144,7 +146,7 @@ module Y3 {
   }
 
   // Apparently this parses :P
-    export
+  export
   private
   public
   protected
diff --git a/crates/rome_js_formatter/tests/specs/prettier/typescript/mapped-type/mapped-type.ts.snap b/crates/rome_js_formatter/tests/specs/prettier/typescript/mapped-type/mapped-type.ts.snap
deleted file mode 100644
index 97451ededd9..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/typescript/mapped-type/mapped-type.ts.snap
+++ /dev/null
@@ -1,44 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
----
-
-# Input
-
-```js
-type Keys = 'option1' | 'option2';
-type A = { [K in Keys] };
-type B = { [K in Keys]+? };
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -1,3 +1,7 @@
- type Keys = "option1" | "option2";
--type A = { [K in Keys] };
--type B = { [K in Keys]+? };
-+type A = {
-+  [K in Keys];
-+};
-+type B = {
-+  [K in Keys]+?;
-+};
-```
-
-# Output
-
-```js
-type Keys = "option1" | "option2";
-type A = {
-  [K in Keys];
-};
-type B = {
-  [K in Keys]+?;
-};
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/typescript/prettier-ignore/mapped-types.ts.snap b/crates/rome_js_formatter/tests/specs/prettier/typescript/prettier-ignore/mapped-types.ts.snap
index 6059651875e..f4a23cdfa13 100644
--- a/crates/rome_js_formatter/tests/specs/prettier/typescript/prettier-ignore/mapped-types.ts.snap
+++ b/crates/rome_js_formatter/tests/specs/prettier/typescript/prettier-ignore/mapped-types.ts.snap
@@ -1,5 +1,7 @@
 ---
 source: crates/rome_js_formatter/tests/prettier_tests.rs
+info:
+  test_file: typescript/prettier-ignore/mapped-types.ts
 ---
 
 # Input
@@ -81,70 +83,42 @@ type a= {
 ```diff
 --- Prettier
 +++ Rome
-@@ -1,55 +1,61 @@
- type a = {
--    // prettier-ignore
--    [A in B]: C  |  D
--  };
-+  // prettier-ignore
-+  [A in B]: C | D;
-+};
- 
- type a = {
--    [
--      // prettier-ignore
--      A in B
--    ]: C  |  D
--  };
-+  [
-+  // prettier-ignore
-+      A in B]: C | D;
-+};
+@@ -11,11 +11,14 @@
+   };
  
  type a = {
 -  [A in B]: C | D; // prettier-ignore
 +  [A in
-+  // prettier-ignore
-+      B]: C | D;
++    // prettier-ignore
++    B]: C | D;
  };
  
  type a = {
 -  A in B: C | D; // prettier-ignore
-+  [A in B]:
-+  // prettier-ignore
-+      C  |  D;
++  [A in B]: // prettier-ignore
++  C | D;
  };
  
  type a = {
--    [
--      /* prettier-ignore */
--      A in B
--    ]: C  |  D
--  };
-+  [
-+  /* prettier-ignore */
-+      A in B]: C | D;
-+};
+@@ -26,11 +29,14 @@
+   };
  
  type a = {
 -  [A /* prettier-ignore */ in B]: C | D;
 +  [A in
-+  /* prettier-ignore */
-+      B]: C | D;
++    /* prettier-ignore */
++    B]: C | D;
  };
  
  type a = {
 -  A in B /* prettier-ignore */: C | D;
-+  [A in B]:
-+  /* prettier-ignore */
-+      C  |  D;
++  [A in B]: /* prettier-ignore */
++  C | D;
  };
  
  type a = {
--    /* prettier-ignore */ [A in B]: C  |  D
--  };
-+  /* prettier-ignore */ [A in B]: C | D;
-+};
+@@ -38,15 +44,15 @@
+   };
  
  type a = {
 -    [/* prettier-ignore */ A in B ]: C  |  D
@@ -162,61 +136,55 @@ type a= {
  };
  
  type a = {
--    /* prettier-ignore */
--    [A in B]: C  |  D
--  };
-+  /* prettier-ignore */
-+  [A in B]: C | D;
-+};
 ```
 
 # Output
 
 ```js
 type a = {
-  // prettier-ignore
-  [A in B]: C | D;
-};
+    // prettier-ignore
+    [A in B]: C  |  D
+  };
 
 type a = {
-  [
-  // prettier-ignore
-      A in B]: C | D;
-};
+    [
+      // prettier-ignore
+      A in B
+    ]: C  |  D
+  };
 
 type a = {
   [A in
-  // prettier-ignore
-      B]: C | D;
+    // prettier-ignore
+    B]: C | D;
 };
 
 type a = {
-  [A in B]:
-  // prettier-ignore
-      C  |  D;
+  [A in B]: // prettier-ignore
+  C | D;
 };
 
 type a = {
-  [
-  /* prettier-ignore */
-      A in B]: C | D;
-};
+    [
+      /* prettier-ignore */
+      A in B
+    ]: C  |  D
+  };
 
 type a = {
   [A in
-  /* prettier-ignore */
-      B]: C | D;
+    /* prettier-ignore */
+    B]: C | D;
 };
 
 type a = {
-  [A in B]:
-  /* prettier-ignore */
-      C  |  D;
+  [A in B]: /* prettier-ignore */
+  C | D;
 };
 
 type a = {
-  /* prettier-ignore */ [A in B]: C | D;
-};
+    /* prettier-ignore */ [A in B]: C  |  D
+  };
 
 type a = {
   [/* prettier-ignore */ A in B]: C | D;
@@ -231,9 +199,9 @@ type a = {
 };
 
 type a = {
-  /* prettier-ignore */
-  [A in B]: C | D;
-};
+    /* prettier-ignore */
+    [A in B]: C  |  D
+  };
 ```
 
 
diff --git a/crates/rome_js_formatter/tests/specs/prettier/typescript/typeof-this/decorators.ts.snap b/crates/rome_js_formatter/tests/specs/prettier/typescript/typeof-this/decorators.ts.snap
deleted file mode 100644
index e9c459e11a2..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/typescript/typeof-this/decorators.ts.snap
+++ /dev/null
@@ -1,46 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
-info:
-  test_file: typescript/typeof-this/decorators.ts
----
-
-# Input
-
-```js
-// https://github.com/typescript-eslint/typescript-eslint/pull/4382
-function decorator() {}
-@decorator
-class Foo {
-  bar(baz: typeof this) {}
-}
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -1,5 +1,6 @@
- // https://github.com/typescript-eslint/typescript-eslint/pull/4382
- function decorator() {}
-+
- @decorator
- class Foo {
-   bar(baz: typeof this) {}
-```
-
-# Output
-
-```js
-// https://github.com/typescript-eslint/typescript-eslint/pull/4382
-function decorator() {}
-
-@decorator
-class Foo {
-  bar(baz: typeof this) {}
-}
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/typescript/union/inlining.ts.snap b/crates/rome_js_formatter/tests/specs/prettier/typescript/union/inlining.ts.snap
deleted file mode 100644
index 5e13f16bc20..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/typescript/union/inlining.ts.snap
+++ /dev/null
@@ -1,134 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
-info:
-  test_file: typescript/union/inlining.ts
----
-
-# Input
-
-```js
-interface RelayProps {
-  articles: a | null,
-}
-interface RelayProps {
-  articles: Array<{
-    __id: string,
-  } | null> | null | void,
-}
-
-type UploadState<E, EM, D>
-  // The upload hasnt begun yet
-  = {type: "Not_begun"}
-  // The upload timed out
-  | {type: "Timed_out"}
-  // Failed somewhere on the line
-  | {type: "Failed", error: E, errorMsg: EM}
-  // Uploading to aws3 and CreatePostMutation succeeded
-  | {type: "Success", data: D};
-
-type UploadState2<E, EM, D>
-  // The upload hasnt begun yet
-  = A
-  // The upload timed out
-  | B
-  // Failed somewhere on the line
-  | C
-  // Uploading to aws3 and CreatePostMutation succeeded
-  | D;
-
-type window = Window & {
-  __REDUX_DEVTOOLS_EXTENSION_COMPOSE__: Function;
-};
-
-type T1 = (number | string)["toString"];
-type T2 = ((number | string))["toString"];
-type T3 = (((number | string)))["toString"];
-type T4 = ((((number | string))))["toString"];
-type T5 = number | ((arg: any) => void);
-type T6 = number | (((arg: any) => void));
-type T7 = number | ((((arg: any) => void)));
-type T8 = number | (((((arg: any) => void))));
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -7,8 +7,9 @@
-   } | null> | null | void;
- }
- 
--type UploadState<E, EM, D> =
--  // The upload hasnt begun yet
-+type UploadState<E, EM, D>
-+// The upload hasnt begun yet
-+=
-   | { type: "Not_begun" }
-   // The upload timed out
-   | { type: "Timed_out" }
-@@ -17,8 +18,9 @@
-   // Uploading to aws3 and CreatePostMutation succeeded
-   | { type: "Success"; data: D };
- 
--type UploadState2<E, EM, D> =
--  // The upload hasnt begun yet
-+type UploadState2<E, EM, D>
-+// The upload hasnt begun yet
-+=
-   | A
-   // The upload timed out
-   | B
-```
-
-# Output
-
-```js
-interface RelayProps {
-  articles: a | null;
-}
-interface RelayProps {
-  articles: Array<{
-    __id: string;
-  } | null> | null | void;
-}
-
-type UploadState<E, EM, D>
-// The upload hasnt begun yet
-=
-  | { type: "Not_begun" }
-  // The upload timed out
-  | { type: "Timed_out" }
-  // Failed somewhere on the line
-  | { type: "Failed"; error: E; errorMsg: EM }
-  // Uploading to aws3 and CreatePostMutation succeeded
-  | { type: "Success"; data: D };
-
-type UploadState2<E, EM, D>
-// The upload hasnt begun yet
-=
-  | A
-  // The upload timed out
-  | B
-  // Failed somewhere on the line
-  | C
-  // Uploading to aws3 and CreatePostMutation succeeded
-  | D;
-
-type window = Window & {
-  __REDUX_DEVTOOLS_EXTENSION_COMPOSE__: Function;
-};
-
-type T1 = (number | string)["toString"];
-type T2 = (number | string)["toString"];
-type T3 = (number | string)["toString"];
-type T4 = (number | string)["toString"];
-type T5 = number | ((arg: any) => void);
-type T6 = number | ((arg: any) => void);
-type T7 = number | ((arg: any) => void);
-type T8 = number | ((arg: any) => void);
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/prettier/typescript/union/prettier-ignore.ts.snap b/crates/rome_js_formatter/tests/specs/prettier/typescript/union/prettier-ignore.ts.snap
deleted file mode 100644
index 17014fa8b06..00000000000
--- a/crates/rome_js_formatter/tests/specs/prettier/typescript/union/prettier-ignore.ts.snap
+++ /dev/null
@@ -1,103 +0,0 @@
----
-source: crates/rome_js_formatter/tests/prettier_tests.rs
-info:
-  test_file: typescript/union/prettier-ignore.ts
----
-
-# Input
-
-```js
-export type a =
-  // foo
-  | foo1&foo2
-  // bar
-  | bar1&bar2
-  // prettier-ignore
-  | qux1&qux2;
-
-export type a =
-  // foo
-  | foo1&foo2
-  // bar
-  | bar1&bar2
-  // prettier-ignore
-  | qux1&qux2
-  // baz
-  | baz1&baz2;
-
-export type a =
-  // prettier-ignore
-  | foo1&foo2
-  // bar
-  | bar1&bar2
-  // qux
-  | qux1&qux2;
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -4,7 +4,7 @@
-   // bar
-   | (bar1 & bar2)
-   // prettier-ignore
--  | qux1&qux2;
-+  | (qux1 & qux2);
- 
- export type a =
-   // foo
-@@ -12,7 +12,7 @@
-   // bar
-   | (bar1 & bar2)
-   // prettier-ignore
--  | qux1&qux2
-+  | (qux1 & qux2)
-   // baz
-   | (baz1 & baz2);
- 
-@@ -20,6 +20,6 @@
-   // prettier-ignore
-   | foo1&foo2
-   // bar
--  | (bar1 & bar2)
-+  | bar1&bar2
-   // qux
--  | (qux1 & qux2);
-+  | qux1&qux2;
-```
-
-# Output
-
-```js
-export type a =
-  // foo
-  | (foo1 & foo2)
-  // bar
-  | (bar1 & bar2)
-  // prettier-ignore
-  | (qux1 & qux2);
-
-export type a =
-  // foo
-  | (foo1 & foo2)
-  // bar
-  | (bar1 & bar2)
-  // prettier-ignore
-  | (qux1 & qux2)
-  // baz
-  | (baz1 & baz2);
-
-export type a =
-  // prettier-ignore
-  | foo1&foo2
-  // bar
-  | bar1&bar2
-  // qux
-  | qux1&qux2;
-```
-
-
-
diff --git a/crates/rome_js_formatter/tests/specs/ts/assignment/assignment.ts.snap b/crates/rome_js_formatter/tests/specs/ts/assignment/assignment.ts.snap
index ae7bc0f84b4..0ff72b43b8b 100644
--- a/crates/rome_js_formatter/tests/specs/ts/assignment/assignment.ts.snap
+++ b/crates/rome_js_formatter/tests/specs/ts/assignment/assignment.ts.snap
@@ -28,7 +28,7 @@ loooooooooooooooooooooooooong1 =
 loooooooooooooooooooooooooong2 =
 	void void "looooooooooooooooooooooooooooooooooooooooooog"!;
 // rome-ignore format: test
-  loooooooooooooooooooooooooong6    =
+loooooooooooooooooooooooooong6    =
 	void    "looooooooooooooooooooooooooooooooooooooooooog"!;
 loooooooooooooooooooooooooong7 =
 	// rome-ignore format: test
diff --git a/crates/rome_js_formatter/tests/specs/ts/declaration/interface.ts.snap b/crates/rome_js_formatter/tests/specs/ts/declaration/interface.ts.snap
index e4132e621be..247753e2489 100644
--- a/crates/rome_js_formatter/tests/specs/ts/declaration/interface.ts.snap
+++ b/crates/rome_js_formatter/tests/specs/ts/declaration/interface.ts.snap
@@ -35,8 +35,7 @@ Quote style: Double Quotes
 Quote properties: As needed
 -----
 interface A {}
-interface B extends A {
-	/** comment **/
+interface B extends A /** comment **/ {
 	something: string;
 }
 
diff --git a/crates/rome_js_formatter/tests/specs/ts/decoartors.ts.snap b/crates/rome_js_formatter/tests/specs/ts/decoartors.ts.snap
index 49174ff2194..8945f7ee7a8 100644
--- a/crates/rome_js_formatter/tests/specs/ts/decoartors.ts.snap
+++ b/crates/rome_js_formatter/tests/specs/ts/decoartors.ts.snap
@@ -93,7 +93,23 @@ class Test2 {
 
 	@test /* trailing multiline comment
 	 for decorator */ @anotherDecorator()
+
 	// leading comment
 	prop: string;
 }
 
+
+## Unimplemented nodes/tokens
+
+"@sealed" => 0..7
+"\t@readonl" => 21..30
+"\t\t@par" => 62..68
+"\t\t@readon" => 77..86
+"\t\t@aVeryLongDecoratorNameLetsSeeWhatHappensWith" => 104..151
+"@param" => 175..181
+"@param" => 219..225
+"@sealed" => 239..246
+"@sealed" => 272..279
+"@test" => 338..343
+"\t@test /* trailing multiline comment\n\t for decorator */ @anotherDecorator(" => 449..523
+
diff --git a/crates/rome_js_formatter/tests/specs/ts/suppressions.ts.snap b/crates/rome_js_formatter/tests/specs/ts/suppressions.ts.snap
index 1e5709bd059..1c6da56df1a 100644
--- a/crates/rome_js_formatter/tests/specs/ts/suppressions.ts.snap
+++ b/crates/rome_js_formatter/tests/specs/ts/suppressions.ts.snap
@@ -21,7 +21,7 @@ Quote properties: As needed
 -----
 interface Suppressions {
 	// rome-ignore format: test
-    a: void
+	a: void
 	b: void;
 }
 
diff --git a/crates/rome_js_formatter/tests/specs/ts/type/conditional.ts.snap b/crates/rome_js_formatter/tests/specs/ts/type/conditional.ts.snap
index 3120a24de3e..8fbd8af7aa6 100644
--- a/crates/rome_js_formatter/tests/specs/ts/type/conditional.ts.snap
+++ b/crates/rome_js_formatter/tests/specs/ts/type/conditional.ts.snap
@@ -44,21 +44,18 @@ type T2 = test extends string
 	: undefined;
 
 type T3 = test extends string
-	?
-	  // something
+	? // something
 	  unknown
 	: test extends number
 	? undefined
-	:
-	  // else
+	: // else
 	  undefined;
 
 type T4 = test extends string
-	// something
-	? unknown
+	? // something
+	  unknown
 	: test extends number
 	? undefined
-	:
-	  // else
+	: // else
 	  undefined;
 
diff --git a/crates/rome_js_formatter/tests/specs/ts/type/intersection_type.ts.snap b/crates/rome_js_formatter/tests/specs/ts/type/intersection_type.ts.snap
index 59ae21d8a90..23bf68c433f 100644
--- a/crates/rome_js_formatter/tests/specs/ts/type/intersection_type.ts.snap
+++ b/crates/rome_js_formatter/tests/specs/ts/type/intersection_type.ts.snap
@@ -126,8 +126,8 @@ type State = {
 
 // spec cases
 //retain comment case
-type TypeWithComments = /*1*/
-	/*2*/ /*3*/ {} /*4*/ & /*5*/ number[] /*6*/ & /*7*/ SomeType /*8*/;
+type TypeWithComments = /*1*/ /*2*/ /*3*/ {} /*4*/ & /*5*/ number[] /*6*/ &
+	/*7*/ SomeType /*8*/;
 
 type IndentAfterDifferentType1 = {} & SomeLongType & {
 		somelonglonglongkey: number;
diff --git a/crates/rome_js_formatter/tests/specs/ts/type/union_type.ts.snap b/crates/rome_js_formatter/tests/specs/ts/type/union_type.ts.snap
index e6c57e353c0..af800684f85 100644
--- a/crates/rome_js_formatter/tests/specs/ts/type/union_type.ts.snap
+++ b/crates/rome_js_formatter/tests/specs/ts/type/union_type.ts.snap
@@ -290,17 +290,14 @@ type LongUnion =
 
 type Comments =
 	// leading separator
-	|
-	  // leading type
-	  A
-	| B /*
-trailing type */;
+	| // leading type
+	A
+	| B; /*
+trailing type */
 
 type A = [
-	|
-	  /*leading comment with new line*/
-	  A
-	| B,
+	/*leading comment with new line*/
+	A | B,
 ];
 
 type RemoveLeadingSeparatorIfNotBreak = /*a*/ /*b*/ A | B;
@@ -309,7 +306,8 @@ type BreakLongTypeAddedLeadingSeparator =
 	| BBBBBBBBBBBBBBBBBBBBBBBB
 	| CCCCCCCCCCCCCCCCCCCCCCCCCCC
 	| DDDDDDDDDDDDDDDDDDDDDDDDDDDDD;
-type BreakLongTypeWithLeadingComment = /*leading comment*/
+type BreakLongTypeWithLeadingComment =
+	/*leading comment*/
 	| BBBBBBBBBBBBBBBBBBBBBBBB
 	| CCCCCCCCCCCCCCCCCCCCCCCCCCC
 	| DDDDDDDDDDDDDDDDDDDDDDDDDDDDD;
@@ -365,10 +363,10 @@ const fooo: SomeThingWithShortMappedType<{
 
 const fooo: SomeThingWithLongMappedType<{
 	[P in
-		| AAAAAAAAAAAAAAAAA
-		| BBBBBBBBBBBB
-		| CCCCCCCCCCCCCCCCCCCCC
-		| DDDDDDDDDDDDDDDDDDDDDDDDDDDDD]: number;
+			| AAAAAAAAAAAAAAAAA
+			| BBBBBBBBBBBB
+			| CCCCCCCCCCCCCCCCCCCCC
+			| DDDDDDDDDDDDDDDDDDDDDDDDDDDDD]: number;
 }> = {};
 
 export type A =

From 6a430dc9b0dd4212356c28e5fd039946fd636c00 Mon Sep 17 00:00:00 2001
From: Micha Reiser <micha@rome.tools>
Date: Thu, 22 Sep 2022 08:16:42 +0200
Subject: [PATCH 15/15] chore(xtask): Part 8: Add line breaks before doc
 comments (#3246)

---
 Cargo.lock                                 |  1 +
 crates/rome_service/src/workspace_types.rs |  2 ++
 xtask/bench/Cargo.toml                     |  3 ++
 xtask/codegen/src/formatter.rs             | 33 ++++++++++++----------
 xtask/codegen/src/generate_bindings.rs     |  1 +
 5 files changed, 25 insertions(+), 15 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 54127814bd9..4d2bbe49ee5 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2840,6 +2840,7 @@ name = "xtask_bench"
 version = "0.0.0"
 dependencies = [
  "ansi_rgb",
+ "countme",
  "criterion",
  "dhat",
  "humansize",
diff --git a/crates/rome_service/src/workspace_types.rs b/crates/rome_service/src/workspace_types.rs
index 3a2674eaff3..ec793f24af3 100644
--- a/crates/rome_service/src/workspace_types.rs
+++ b/crates/rome_service/src/workspace_types.rs
@@ -65,6 +65,7 @@ fn instance_type<'a>(
                     if let Some(description) = description {
                         let comment = format!("/**\n\t* {} \n\t */", description);
                         let trivia = vec![
+                            (TriviaPieceKind::Newline, "\n"),
                             (TriviaPieceKind::MultiLineComment, comment.as_str()),
                             (TriviaPieceKind::Newline, "\n"),
                         ];
@@ -337,6 +338,7 @@ pub fn generate_type<'a>(
                 if let Some(description) = description {
                     let comment = format!("/**\n\t* {} \n\t */", description);
                     let trivia = vec![
+                        (TriviaPieceKind::Newline, "\n"),
                         (TriviaPieceKind::MultiLineComment, comment.as_str()),
                         (TriviaPieceKind::Newline, "\n"),
                     ];
diff --git a/xtask/bench/Cargo.toml b/xtask/bench/Cargo.toml
index ebe77d3f59a..6ad24dc2001 100644
--- a/xtask/bench/Cargo.toml
+++ b/xtask/bench/Cargo.toml
@@ -23,6 +23,8 @@ url = "2.2.2"
 itertools = "0.10.3"
 ansi_rgb = "0.2.0"
 
+countme = "3.0.1"
+
 # dhat-on
 dhat = { version = "0.3.0", optional = true }
 humansize = {version = "1.1.1", optional = true }
@@ -35,3 +37,4 @@ tikv-jemallocator = "0.5.0"
 
 [features]
 dhat-heap = ["dhat", "humansize"]
+count = ["countme/print_at_exit"]
diff --git a/xtask/codegen/src/formatter.rs b/xtask/codegen/src/formatter.rs
index b044d6e71b3..ba707c0c1fd 100644
--- a/xtask/codegen/src/formatter.rs
+++ b/xtask/codegen/src/formatter.rs
@@ -357,18 +357,13 @@ pub fn generate_formatter() {
             }
             NodeKind::Unknown => {
                 quote! {
-                    use crate::prelude::*;
-                    use crate::{FormatNodeFields};
-                    use rome_rowan::AstNode;
+                    use crate::FormatUnknownNodeRule;
                     use rome_js_syntax::#node_id;
 
                     #[derive(Debug, Clone, Default)]
                     pub struct #format_id;
 
-                    impl FormatNodeRule<#node_id> for #format_id {
-                        fn fmt_fields(&self, node: &#node_id, f: &mut JsFormatter) -> FormatResult<()> {
-                            format_unknown_node(node.syntax()).fmt(f)
-                        }
+                    impl FormatUnknownNodeRule<#node_id> for #format_id {
                     }
                 }
             }
@@ -437,15 +432,23 @@ impl BoilerplateImpls {
     fn push(&mut self, kind: &NodeKind, node_id: &Ident, format_id: &TokenStream) {
         let format_rule_impl = match kind {
             NodeKind::List { .. } | NodeKind::Union { .. } => quote!(),
-            _ => quote! {
-                impl FormatRule<rome_js_syntax::#node_id> for #format_id {
-                   type Context = JsFormatContext;
-                    #[inline(always)]
-                    fn fmt(&self, node: &rome_js_syntax::#node_id, f: &mut JsFormatter) -> FormatResult<()> {
-                        FormatNodeRule::<rome_js_syntax::#node_id>::fmt(self, node, f)
+            kind => {
+                let rule = if matches!(kind, NodeKind::Unknown) {
+                    Ident::new("FormatUnknownNodeRule", Span::call_site())
+                } else {
+                    Ident::new("FormatNodeRule", Span::call_site())
+                };
+
+                quote! {
+                    impl FormatRule<rome_js_syntax::#node_id> for #format_id {
+                       type Context = JsFormatContext;
+                        #[inline(always)]
+                        fn fmt(&self, node: &rome_js_syntax::#node_id, f: &mut JsFormatter) -> FormatResult<()> {
+                            #rule::<rome_js_syntax::#node_id>::fmt(self, node, f)
+                        }
                     }
                 }
-            },
+            }
         };
 
         self.impls.push(quote! {
@@ -474,7 +477,7 @@ impl BoilerplateImpls {
 
         let tokens = quote! {
             use rome_formatter::{FormatRefWithRule, FormatOwnedWithRule, FormatRule, FormatResult};
-            use crate::{AsFormat, IntoFormat, FormatNodeRule, JsFormatter, JsFormatContext};
+            use crate::{AsFormat, IntoFormat, FormatNodeRule, FormatUnknownNodeRule, JsFormatter, JsFormatContext};
 
             #( #impls )*
         };
diff --git a/xtask/codegen/src/generate_bindings.rs b/xtask/codegen/src/generate_bindings.rs
index d3b1417ec69..1c9dcd6790d 100644
--- a/xtask/codegen/src/generate_bindings.rs
+++ b/xtask/codegen/src/generate_bindings.rs
@@ -194,6 +194,7 @@ pub(crate) fn generate_workspace_bindings(mode: Mode) -> Result<()> {
         if let Some(description) = description {
             let comment = format!("/**\n\t* {} \n\t */\n", description);
             let trivia = vec![
+                (TriviaPieceKind::Newline, "\n"),
                 (TriviaPieceKind::MultiLineComment, comment.as_str()),
                 (TriviaPieceKind::Newline, "\n"),
             ];