go

Author: Dunqing

crates/oxc_formatter/src/formatter/source_text.rs

@@ -129,13 +129,24 @@ impl<'a> SourceText<'a> {
         self.text_for(&span).chars().count()
     }
 
-    /// Count consecutive line breaks after position
+    /// Count consecutive line breaks after position, returning `0` if only whitespace follows
     pub fn lines_after(&self, end: u32) -> usize {
-        self.slice_from(end)
-            .chars()
-            .filter(|&c| !is_white_space_single_line(c))
-            .take_while(|&c| is_line_terminator(c))
-            .count()
+        let mut count = 0;
+        for char in self.slice_from(end).chars() {
+            if is_white_space_single_line(char) {
+                continue;
+            }
+
+            if is_line_terminator(char) {
+                count += 1;
+                continue;
+            }
+
+            return count;
+        }
+
+        // No non-whitespace characters found after position, so return `0` to avoid adding extra new lines
+        0
     }
 
     /// Count line breaks between syntax nodes, considering comments and parentheses
@@ -188,7 +199,7 @@ impl<'a> SourceText<'a> {
             count += 1;
         }
 
-        count
+        0
     }
 
     pub fn is_own_line_comment(&self, comment: &Comment) -> bool {

crates/oxc_formatter/src/utils/conditional.rs

@@ -144,13 +144,13 @@ fn format_trailing_comments<'a>(
             if source_text.contains_newline_between(start, comment.span.start) {
                 return &comments[..index];
             }
-            // If this comment is a line comment, then it is a end of line comment, so we stop here and return the comments with this comment
-            else if comment.is_line() {
+            // If this comment is a line comment or an end of line comment, so we stop here and return the comments with this comment
+            else if comment.is_line() || source_text.is_end_of_line_comment(comment) {
                 return &comments[..=index];
             }
             // Store the index of the comment before the operator, if no line comment or no new line is found, then return all comments before operator
             else if source_text.bytes_contain(start, comment.span.start, operator) {
-                index_before_operator = Some(index + 1);
+                index_before_operator = Some(index);
             }
 
             // Update the start position for the next iteration

crates/oxc_formatter/src/utils/typecast.rs

@@ -60,24 +60,36 @@ pub fn format_type_cast_comment_node<'a, T>(
 
         write!(f, [FormatLeadingComments::Comments(type_cast_comments)])?;
         f.context_mut().comments_mut().mark_as_handled_type_cast_comment();
-    } else {
-        let elements = f.elements().iter().rev();
-
         // If the printed cast comment is already handled, return early to avoid infinite recursion.
-        if !comments.is_already_handled_type_cast_comment()
-            && comments.printed_comments().last().is_some_and(|c| {
-                c.span.end <= span.start
-                    && source.all_bytes_match(c.span.end, span.start, |c| {
-                        c.is_ascii_whitespace() || c == b'('
-                    })
-                    && f.comments().is_type_cast_comment(c)
-            })
+    } else if !comments.is_already_handled_type_cast_comment()
+        && let Some(last_printed_comment) = comments.printed_comments().last()
+    {
+        if !last_printed_comment.span.end <= span.start
+            || !f.comments().is_type_cast_comment(last_printed_comment)
         {
-            f.context_mut().comments_mut().mark_as_handled_type_cast_comment();
-        } else {
-            // No typecast comment
             return Ok(false);
         }
+
+        let mut has_left_paren = false;
+        // Check whether there is only whitespace or left parenthesis between the comment and the node
+        for &byte in source.bytes_range(last_printed_comment.span.end, span.start) {
+            if !byte.is_ascii_whitespace() {
+                if byte == b'(' {
+                    has_left_paren = true;
+                } else {
+                    return Ok(false);
+                }
+            }
+        }
+
+        if !has_left_paren {
+            return Ok(false);
+        }
+
+        f.context_mut().comments_mut().mark_as_handled_type_cast_comment();
+    } else {
+        // No typecast comment
+        return Ok(false);
     }
 
     // https://github.com/prettier/prettier/blob/7584432401a47a26943dd7a9ca9a8e032ead7285/src/language-js/print/estree.js#L117-L120

crates/oxc_formatter/src/write/call_arguments.rs

@@ -96,8 +96,10 @@ impl<'a> Format<'a> for AstNode<'a, ArenaVec<'a, Argument<'a>>> {
             );
         }
 
-        let has_empty_line =
-            self.iter().any(|arg| f.source_text().get_lines_before(arg.span(), f.comments()) > 1);
+        let has_empty_line = self
+            .iter()
+            .skip(1)
+            .any(|arg| f.source_text().get_lines_before(arg.span(), f.comments()) > 1);
         if has_empty_line
             || (!matches!(self.parent.parent(), AstNodes::Decorator(_))
                 && is_function_composition_args(self))

crates/oxc_formatter/src/write/program.rs

@@ -7,7 +7,7 @@ use oxc_syntax::identifier::{ZWNBSP, is_line_terminator};
 
 use crate::{
     Buffer, Format, FormatResult, FormatTrailingCommas, TrailingSeparator, format_args,
-    formatter::{prelude::*, separated::FormatSeparatedIter, trivia::FormatTrailingComments},
+    formatter::{prelude::*, trivia::FormatTrailingComments},
     generated::ast_nodes::{AstNode, AstNodes},
     utils::{
         call_expression::is_test_call_expression,
@@ -25,7 +25,7 @@ impl<'a> FormatWrite<'a> for AstNode<'a, Program<'a>> {
     fn write(&self, f: &mut Formatter<'_, 'a>) -> FormatResult<()> {
         let format_trailing_comments = format_once(|f| {
             let comments = f.context().comments().comments_before(self.span.end);
-            FormatTrailingComments::Comments(comments).fmt(f)
+            write!(f, FormatTrailingComments::Comments(comments))
         });
 
         write!(
@@ -112,19 +112,8 @@ impl<'a> Format<'a> for AstNode<'a, Vec<'a, Directive<'a>>> {
         // }
         //```
         // so we should keep an extra empty line after JsDirectiveList
-        let source_text = f.context().source_text();
-        let mut count = 0;
-        let mut source_text_chars = source_text.slice_from(last_directive.span.end).chars();
-        for char in source_text_chars.by_ref() {
-            if is_line_terminator(char) {
-                count += 1;
-            } else if !char.is_whitespace() {
-                break;
-            }
-        }
 
-        // Need an extra empty line if it has the following line and still has non-characters after whitespace.
-        let need_extra_empty_line = source_text_chars.next().is_some() && count > 1;
+        let need_extra_empty_line = f.source_text().lines_after(last_directive.span.end) > 1;
         write!(f, if need_extra_empty_line { empty_line() } else { hard_line_break() })
     }
 }

tasks/coverage/snapshots/formatter_babel.snap

@@ -2,8 +2,6 @@ commit: 41d96516
 
 formatter_babel Summary:
 AST Parsed     : 2423/2423 (100.00%)
-Positive Passed: 2421/2423 (99.92%)
-Mismatch: tasks/coverage/babel/packages/babel-parser/test/fixtures/es2015/class/division/input.js
-
+Positive Passed: 2422/2423 (99.96%)
 Expect to Parse: tasks/coverage/babel/packages/babel-parser/test/fixtures/es2022/top-level-await-unambiguous/module/input.js
 `await` is only allowed within async functions and at the top levels of modules