fix(formatter): incorrect comments checking (#12356)

Due to our printing comments architecture is different from `Biome`, so it may incorrectly implement the comments checking parts. But fortunately, those will be caught as the port work gradually nears done.

Author: Dunqing

crates/oxc_formatter/src/formatter/builders.rs

@@ -1,12 +1,12 @@
-use std::{borrow::Cow, cell::Cell, num::NonZeroU8};
+use std::{backtrace, borrow::Cow, cell::Cell, num::NonZeroU8};
 
 use Tag::{
     EndAlign, EndConditionalContent, EndDedent, EndEntry, EndFill, EndGroup, EndIndent,
     EndIndentIfGroupBreaks, EndLabelled, EndLineSuffix, StartAlign, StartConditionalContent,
     StartDedent, StartEntry, StartFill, StartGroup, StartIndent, StartIndentIfGroupBreaks,
     StartLabelled, StartLineSuffix,
 };
-use oxc_span::Span;
+use oxc_span::{GetSpan, Span};
 use oxc_syntax::identifier::{is_line_terminator, is_white_space_single_line};
 
 use super::{
@@ -2454,37 +2454,63 @@ where
 
     /// Get the number of line breaks between two consecutive SyntaxNodes in the tree
     pub fn has_lines_before(&self, span: Span) -> bool {
-        get_lines_before(span.start, self.fmt) > 1
+        get_lines_before(span, self.fmt) > 1
     }
 }
 
 /// Get the number of line breaks between two consecutive SyntaxNodes in the tree
-pub fn get_lines_before(start: u32, f: &Formatter) -> usize {
-    // Count the newlines in the leading trivia of the next node
+pub fn get_lines_before(span: Span, f: &Formatter) -> usize {
+    let mut start = span.start;
+
+    // Should skip the leading comments of the node.
     let comments = f.comments().unprinted_comments();
-    let start = if let Some(comment) = comments.first() {
-        if comment.span.end < start { comment.span.start } else { start }
-    } else {
-        start
-    };
-
-    f.source_text()[..start as usize]
-        // TODO: This is a workaround.
-        // Trim `(` because we turned off `preserveParens`, which causes us to not have a parenthesis node,
-        // but you will still find `(` or `)` in the source text.
-        .trim_end_matches(|c| is_white_space_single_line(c) || c == '(')
-        .chars()
-        .rev()
-        .take_while(|c| is_line_terminator(*c))
-        .count()
+    if let Some(comment) = comments.first() {
+        if comment.span.end < start {
+            start = comment.span.start;
+        }
+    }
+
+    // Count the newlines in the leading trivia of the next node
+    let mut count = 0;
+    let mut right_parent_start = span.end as usize;
+    for c in f.source_text()[..start as usize].chars().rev() {
+        if is_white_space_single_line(c) {
+            continue;
+        }
+
+        if c == '(' {
+            // We don't have a parenthesis node when `preserveParens` is turned off,
+            // but we will find the `(` and `)` around the node if it exists.
+            // If we find a `(`, we try to find the matching `)` and reset the count.
+            // This is necessary to avoid counting the newlines inside the parenthesis.
+
+            let Some((pos, ')')) =
+                f.source_text()[right_parent_start..].trim_start().chars().enumerate().next()
+            else {
+                return count;
+            };
+
+            right_parent_start = pos;
+            count = 0;
+            continue;
+        }
+
+        if !is_line_terminator(c) {
+            return count;
+        }
+
+        count += 1;
+    }
+
+    count
 }
 
 /// Get the number of line breaks between two consecutive SyntaxNodes in the tree
 pub fn get_lines_after(end: u32, source_text: &str) -> usize {
     source_text[end as usize..]
-        .trim_start_matches(is_white_space_single_line)
         .chars()
-        .take_while(|c| is_line_terminator(*c))
+        .filter(|&c| !is_white_space_single_line(c))
+        .take_while(|&c| is_line_terminator(c))
         .count()
 }
 

crates/oxc_formatter/src/formatter/comments/mod.rs

@@ -6,7 +6,10 @@ use std::{
 };
 
 use oxc_allocator::Vec;
-use oxc_ast::{Comment, CommentKind, ast};
+use oxc_ast::{
+    Comment, CommentKind,
+    ast::{self, CallExpression, NewExpression},
+};
 use oxc_span::{GetSpan, Span};
 
 use crate::{
@@ -30,42 +33,40 @@ impl<'a> Comments<'a> {
         Comments { source_text, comments, printed_count: 0 }
     }
 
+    /// Returns comments that not printed yet.
     #[inline]
     pub fn unprinted_comments(&self) -> &'a [Comment] {
         &self.comments[self.printed_count..]
     }
 
+    /// Returns comments that were printed already.
+    #[inline]
+    pub fn printed_comments(&self) -> &'a [Comment] {
+        &self.comments[..self.printed_count]
+    }
+
     /// Returns the comments that after the given `start` position, even if they were already printed.
-    pub fn comments_after(&self, start: u32) -> &'a [Comment] {
+    pub fn comments_after(&self, pos: u32) -> &'a [Comment] {
         let mut index = self.printed_count;
 
         // No comments or all are printed already
         if index == self.comments.len() {
             return &[];
         }
 
-        let forward = self.comments[index].span.end < start;
-        // Skip comments that before start
-        if forward {
-            while index < self.comments.len() - 1 {
-                if self.comments[index + 1].span.end <= start {
-                    index += 1;
-                    continue;
-                }
-                break;
-            }
-        } else {
-            // Find comments that after start
-            while index > 0 {
-                if self.comments[index - 1].span.start > start {
-                    index -= 1;
-                    continue;
-                }
-                break;
-            }
+        // You may want to check comments after your are printing the node,
+        // so it may have a lot of comments that don't print yet.
+        //
+        // Skip comments that before pos
+        while index < self.comments.len() - 1 && self.comments[index].span.end < pos {
+            index += 1;
         }
 
-        &self.comments[index..]
+        if self.comments[index].span.end < pos {
+            &self.comments[index + 1..]
+        } else {
+            &self.comments[index..]
+        }
     }
 
     #[inline]
@@ -243,6 +244,100 @@ impl<'a> Comments<'a> {
     pub fn increment_printed_count(&mut self) {
         self.printed_count += 1;
     }
+
+    pub fn get_trailing_comments(
+        &self,
+        enclosing_node: &SiblingNode<'a>,
+        preceding_node: &SiblingNode<'a>,
+        following_node: Option<&SiblingNode<'a>>,
+    ) -> &'a [Comment] {
+        // The preceding_node is the callee of the call expression or new expression, let following node to print it.
+        // Based on https://github.com/prettier/prettier/blob/7584432401a47a26943dd7a9ca9a8e032ead7285/src/language-js/comments/handle-comments.js#L726-L741
+        if matches!(enclosing_node, SiblingNode::CallExpression(CallExpression { callee, ..}) | SiblingNode::NewExpression(NewExpression { callee, ..}) if callee.span().contains_inclusive(preceding_node.span()))
+        {
+            return &[];
+        }
+
+        let comments = self.unprinted_comments();
+        if comments.is_empty() {
+            return &[];
+        }
+
+        let source_text = self.source_text;
+        let preceding_span = preceding_node.span();
+
+        // All of the comments before this node are printed already.
+        debug_assert!(
+            comments.first().is_none_or(|comment| comment.span.end > preceding_span.start)
+        );
+
+        let Some(following_node) = following_node else {
+            let enclosing_span = enclosing_node.span();
+            return comments
+                .iter()
+                .enumerate()
+                .take_while(|(_, comment)| comment.span.end <= enclosing_span.end)
+                .last()
+                .map_or(&[], |(index, _)| &comments[..=index]);
+        };
+
+        let following_span = following_node.span();
+        let mut comment_index = 0;
+        while let Some(comment) = comments.get(comment_index) {
+            // Check if the comment is before the following node's span
+            if comment.span.end > following_span.start {
+                break;
+            }
+
+            if is_own_line_comment(comment, source_text) {
+                // TODO: describe the logic here
+                // Reached an own line comment, which means it is the leading comment for the next node.
+                break;
+            } else if is_end_of_line_comment(comment, source_text) {
+                // Should be a leading comment of following node.
+                // Based on https://github.com/prettier/prettier/blob/7584432401a47a26943dd7a9ca9a8e032ead7285/src/language-js/comments/handle-comments.js#L852-L883
+                if matches!(
+                    enclosing_node,
+                    SiblingNode::VariableDeclarator(_)
+                        | SiblingNode::AssignmentExpression(_)
+                        | SiblingNode::TSTypeAliasDeclaration(_)
+                ) && (comment.is_block()
+                    || matches!(
+                        following_node,
+                        SiblingNode::ObjectExpression(_)
+                            | SiblingNode::ArrayExpression(_)
+                            | SiblingNode::TSTypeLiteral(_)
+                            | SiblingNode::TemplateLiteral(_)
+                            | SiblingNode::TaggedTemplateExpression(_)
+                    ))
+                {
+                    return &[];
+                }
+                return &comments[..=comment_index];
+            }
+
+            comment_index += 1;
+        }
+
+        if comment_index == 0 {
+            // No comments to print
+            return &[];
+        }
+
+        let mut gap_end = following_span.start;
+        for cur_index in (0..comment_index).rev() {
+            let comment = &comments[cur_index];
+            let gap_str = Span::new(comment.span.end, gap_end).source_text(source_text);
+            if gap_str.as_bytes().iter().all(|&b| matches!(b, b' ' | b'(')) {
+                gap_end = comment.span.start;
+            } else {
+                // If there is a non-whitespace character, we stop here
+                return &comments[..=cur_index];
+            }
+        }
+
+        &[]
+    }
 }
 
 #[inline]