diff --git a/Cargo.lock b/Cargo.lock
index d8fd1524a0c..1a4de63b6a9 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1571,6 +1571,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..711f9a2f1e6 100644
--- a/crates/rome_formatter/src/comments.rs
+++ b/crates/rome_formatter/src/comments.rs
@@ -1,12 +1,90 @@
+//! 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;
 
-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)]
@@ -15,9 +93,7 @@ pub enum CommentKind {
     ///
     /// ## Examples
     ///
-    /// ### JavaScript:
-    ///
-    /// ```javascript
+    /// ```ignore
     /// a /* test */
     /// ```
     InlineBlock,
@@ -26,8 +102,6 @@ pub enum CommentKind {
     ///
     /// ## Examples
     ///
-    /// ### JavaScript
-    ///
     /// ```javascript
     /// /* first line
     ///  * more content on the second line
@@ -39,111 +113,660 @@ pub enum CommentKind {
     ///
     /// ## Examples
     ///
-    /// ### JavaScript
-    ///
-    /// ```javascript
+    /// ```ignore
     /// a // test
     /// ```
     Line,
 }
 
+impl CommentKind {
+    pub const fn is_line(&self) -> bool {
+        matches!(self, CommentKind::Line)
+    }
+
+    pub const fn is_block(&self) -> bool {
+        matches!(self, CommentKind::Block)
+    }
+
+    pub const fn is_inline_block(&self) -> bool {
+        matches!(self, CommentKind::InlineBlock)
+    }
+
+    /// Returns `true` for comments that can appear inline between any two tokens.
+    ///
+    /// ## Examples
+    ///
+    /// ```rust
+    /// use rome_formatter::comments::CommentKind;
+    ///
+    /// // Block and InlineBlock comments can appear inline
+    /// assert!(CommentKind::Block.is_inline());
+    /// assert!(CommentKind::InlineBlock.is_inline());
+    ///
+    /// // But not line comments
+    /// assert!(!CommentKind::Line.is_inline())
+    /// ```
+    pub const fn is_inline(&self) -> bool {
+        matches!(self, CommentKind::InlineBlock | CommentKind::Block)
+    }
+}
+
+/// A comment in the source document.
 #[derive(Debug, Clone)]
 pub struct SourceComment<L: Language> {
     /// The number of lines appearing before this comment
-    lines_before: u32,
+    pub(crate) lines_before: u32,
+
+    pub(crate) lines_after: u32,
 
     /// The comment piece
-    piece: SyntaxTriviaPieceComments<L>,
+    pub(crate) piece: SyntaxTriviaPieceComments<L>,
+
+    /// The kind of the comment.
+    pub(crate) kind: CommentKind,
 }
 
 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,
-        }
+    /// Returns the underlining comment trivia piece
+    pub fn piece(&self) -> &SyntaxTriviaPieceComments<L> {
+        &self.piece
     }
 
-    /// Creates a leading comment with the specified lines before
-    pub fn leading(piece: SyntaxTriviaPieceComments<L>, lines_before: u32) -> Self {
-        Self {
-            lines_before,
-            piece,
-        }
+    /// 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
     }
 
-    /// Returns the underlining comment trivia piece
+    /// 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
+    }
+
+    /// The kind of the comment
+    pub fn kind(&self) -> CommentKind {
+        self.kind
+    }
+}
+
+/// 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>,
+    text_position: CommentTextPosition,
+    lines_before: u32,
+    lines_after: u32,
+    comment: SyntaxTriviaPieceComments<L>,
+    kind: CommentKind,
+}
+
+impl<L: Language> DecoratedComment<L> {
+    /// 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.piece
+        &self.comment
     }
 
-    /// Returns the number of lines before directly before this comment
+    /// 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()
+    }
+
+    /// 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 line breaks 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 [CommentKind] of the comment.
+    pub fn kind(&self) -> CommentKind {
+        self.kind
+    }
+
+    /// 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
+    }
 }
 
-impl CommentKind {
-    pub const fn is_line(&self) -> bool {
-        matches!(self, CommentKind::Line)
+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,
+        }
     }
+}
 
-    pub const fn is_block(&self) -> bool {
-        matches!(self, CommentKind::Block)
+/// The position of a comment in the source text.
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+pub enum CommentTextPosition {
+    /// 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.
+    ///
+    /// # 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.
+    ///
+    /// # 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.
+    ///
+    /// # Examples
+    ///
+    /// ```ignore
+    /// a /* comment */ + b
+    /// ```
+    SameLine,
+}
+
+impl CommentTextPosition {
+    pub const fn is_same_line(&self) -> bool {
+        matches!(self, CommentTextPosition::SameLine)
     }
 
-    pub const fn is_inline_block(&self) -> bool {
-        matches!(self, CommentKind::InlineBlock)
+    pub const fn is_own_line(&self) -> bool {
+        matches!(self, CommentTextPosition::OwnLine)
     }
 
-    /// Returns `true` for comments that can appear inline between any two tokens.
+    pub const fn is_end_of_line(&self) -> bool {
+        matches!(self, CommentTextPosition::EndOfLine)
+    }
+}
+
+#[derive(Debug)]
+pub enum CommentPlacement<L: Language> {
+    /// Makes `comment` a [leading comment](self#leading-comments) of `node`.
+    Leading {
+        node: SyntaxNode<L>,
+        comment: SourceComment<L>,
+    },
+    /// Makes `comment` a [trailing comment](self#trailing-comments) of `node`.
+    Trailing {
+        node: SyntaxNode<L>,
+        comment: SourceComment<L>,
+    },
+
+    /// Makes `comment` a [dangling comment](self#dangling-comments) of `node`.
+    Dangling {
+        node: SyntaxNode<L>,
+        comment: SourceComment<L>,
+    },
+
+    /// 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
     ///
-    /// ```rust
-    /// use rome_formatter::CommentKind;
+    /// ```ignore
+    /// [
+    ///     a, // comment
+    ///     b
+    /// ]
+    /// ```
     ///
-    /// // Block and InlineBlock comments can appear inline
-    /// assert!(CommentKind::Block.is_inline());
-    /// assert!(CommentKind::InlineBlock.is_inline());
+    /// The comment becomes a [trailing comment] of the node `a`.
     ///
-    /// // But not line comments
-    /// assert!(!CommentKind::Line.is_inline())
+    /// ### Comment with preceding node only
+    ///
+    /// ```ignore
+    /// [
+    ///     a // comment
+    /// ]
     /// ```
-    pub const fn is_inline(&self) -> bool {
-        matches!(self, CommentKind::InlineBlock | CommentKind::Block)
+    ///
+    /// 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 {
+            node,
+            comment: comment.into(),
+        }
+    }
+
+    /// 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,
+            comment: comment.into(),
+        }
+    }
+
+    /// 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 {
+            node,
+            comment: comment.into(),
+        }
+    }
+
+    /// Returns the placement if it isn't [CommentPlacement::Default], otherwise calls `f` and returns the result.
+    #[inline]
+    pub fn or_else<F>(self, f: F) -> Self
+    where
+        F: FnOnce(DecoratedComment<L>) -> CommentPlacement<L>,
+    {
+        match self {
+            CommentPlacement::Default(comment) => f(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;
+
+    /// Determines the placement of `comment`.
+    ///
+    /// The default implementation returns [CommentPlacement::Default].
+    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:
-///
-/// * 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, 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]
@@ -164,67 +787,113 @@ 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
+    /// Extracts all the comments from `root` and its descendants nodes.
+    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;
-                    }
+        let builder = CommentsBuilderVisitor::new(style, source_map);
 
-                    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 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 passed `node` has a leading suppression comment.
+    /// 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](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 comments](self#leading-comments) that have a leading line break.
     ///
-    /// Suppression comments only apply if they are at the start of a node and they suppress the most
-    /// outer node.
+    /// 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](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](self#dangling-comments).
+    pub fn has_dangling_comments(&self, node: &SyntaxNode<L>) -> bool {
+        !self.dangling_comments(node).is_empty()
+    }
+
+    /// 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](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](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](self#leading-comments) and [trailing comments](self#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](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>,
+    ) -> 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 `node` has a [leading](self#leading-comments), [dangling](self#dangling-comments), or [trailing](self#trailing-comments) suppression comment.
     ///
     /// # Examples
     ///
@@ -237,7 +906,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 +934,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 +961,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 +979,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..e666f779631
--- /dev/null
+++ b/crates/rome_formatter/src/comments/builder.rs
@@ -0,0 +1,1004 @@
+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,
+    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
+                        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;
+                }
+            }
+        }
+
+        // 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,
+                    text_position: 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.text_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.text_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.text_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 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,
+        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.text_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.text_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.text_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.text_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.text_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.text_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.text_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.text_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.text_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..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,7 +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, CommentStyle, Comments, 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;
@@ -232,14 +233,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 +822,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 +871,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);
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};