correct comments printing between function name with params and between function params with body

Author: Dunqing

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

@@ -60,6 +60,20 @@ impl<'a> Comments<'a> {
         &comments[..index]
     }
 
+    pub fn block_comments_before(&self, pos: u32) -> &'a [Comment] {
+        let mut index = 0;
+
+        let comments = self.unprinted_comments();
+        for comment in comments {
+            if comment.span.end > pos || !comment.is_block() {
+                break;
+            }
+            index += 1;
+        }
+
+        &comments[..index]
+    }
+
     /// Returns own line comments that are before the given `pos`.
     pub fn own_line_comments_before(&self, pos: u32) -> &'a [Comment] {
         let mut index = 0;

crates/oxc_formatter/src/formatter/trivia.rs

@@ -97,12 +97,7 @@ impl<'a> Format<'a> for FormatLeadingComments<'a> {
 
         match self {
             Self::Node(span) => {
-                let leading_comments = f
-                    .context()
-                    .comments()
-                    .unprinted_comments()
-                    .iter()
-                    .take_while(|comment| comment.span.end <= span.start);
+                let leading_comments = f.context().comments().comments_before(span.start);
                 format_leading_comments_impl(leading_comments, f)
             }
             Self::Comments(comments) => format_leading_comments_impl(*comments, f),
@@ -356,11 +351,7 @@ impl<'a> Format<'a> for FormatDanglingComments<'a> {
             FormatDanglingComments::Node { span, indent } => {
                 let source_text = f.context().source_text();
                 format_dangling_comments_impl(
-                    f.context()
-                        .comments()
-                        .unprinted_comments()
-                        .iter()
-                        .take_while(|comment| span.contains_inclusive(comment.span)),
+                    f.context().comments().comments_before(span.end),
                     *indent,
                     f,
                 )

crates/oxc_formatter/src/generated/format.rs

@@ -920,10 +920,7 @@ impl<'a> Format<'a> for AstNode<'a, FormalParameter<'a>> {
 
 impl<'a> Format<'a> for AstNode<'a, FunctionBody<'a>> {
     fn fmt(&self, f: &mut Formatter<'_, 'a>) -> FormatResult<()> {
-        self.format_leading_comments(f)?;
-        let result = self.write(f);
-        self.format_trailing_comments(f)?;
-        result
+        self.write(f)
     }
 }
 

crates/oxc_formatter/src/write/arrow_function_expression.rs

@@ -5,8 +5,11 @@ use crate::{
     format_args,
     formatter::{
         Buffer, Comments, Format, FormatError, FormatResult, Formatter,
-        buffer::RemoveSoftLinesBuffer, comments::has_new_line_backward, prelude::*,
-        trivia::format_trailing_comments, write,
+        buffer::RemoveSoftLinesBuffer,
+        comments::has_new_line_backward,
+        prelude::*,
+        trivia::{FormatLeadingComments, format_trailing_comments},
+        write,
     },
     generated::ast_nodes::{AstNode, AstNodes},
     options::FormatTrailingCommas,

crates/oxc_formatter/src/write/block_statement.rs

@@ -22,15 +22,8 @@ impl<'a> FormatWrite<'a> for AstNode<'a, BlockStatement<'a>> {
             // `if (a) { /* comment */ }`
             //
             // Some comments are not inside the block, but we need to print them inside the block.
-            let comments = f.context().comments().comments_before(self.span.end);
-            if !comments.is_empty() {
-                write!(
-                    f,
-                    FormatDanglingComments::Comments {
-                        comments,
-                        indent: DanglingIndentMode::Block,
-                    }
-                )?;
+            if f.context().comments().has_comments_before(self.span.end) {
+                write!(f, format_dangling_comments(self.span).with_block_indent())?;
             } else if is_non_collapsible(self.parent) {
                 write!(f, hard_line_break())?;
             }

crates/oxc_formatter/src/write/function.rs

@@ -10,8 +10,10 @@ use super::{
 use crate::{
     format_args,
     formatter::{
-        Buffer, FormatError, FormatResult, Formatter, buffer::RemoveSoftLinesBuffer, prelude::*,
-        trivia::DanglingIndentMode,
+        Buffer, FormatError, FormatResult, Formatter,
+        buffer::RemoveSoftLinesBuffer,
+        prelude::*,
+        trivia::{DanglingIndentMode, FormatLeadingComments},
     },
     generated::ast_nodes::AstNode,
     write,
@@ -145,6 +147,11 @@ impl<'a> FormatWrite<'a, FormatFunctionOptions> for AstNode<'a, Function<'a>> {
 
 impl<'a> FormatWrite<'a> for AstNode<'a, FunctionBody<'a>> {
     fn write(&self, f: &mut Formatter<'_, 'a>) -> FormatResult<()> {
+        let comments = f.context().comments().block_comments_before(self.span.start);
+        if !comments.is_empty() {
+            write!(f, [space(), FormatLeadingComments::Comments(comments)])?;
+        }
+
         let statements = self.statements();
         let directives = self.directives();
         if is_empty_block(statements, f) && directives.is_empty() {

crates/oxc_formatter/src/write/mod.rs

@@ -656,7 +656,7 @@ impl<'a> FormatWrite<'a> for AstNode<'a, ForStatement<'a>> {
                     [
                         FormatDanglingComments::Comments {
                             comments,
-                            indent: DanglingIndentMode::None,
+                            indent: DanglingIndentMode::None
                         },
                         soft_line_break_or_space()
                     ]
@@ -777,8 +777,10 @@ impl<'a> FormatWrite<'a> for AstNode<'a, IfStatement<'a>> {
             }
 
             if has_dangling_comments {
-                FormatDanglingComments::Comments { comments, indent: DanglingIndentMode::None }
-                    .fmt(f)?;
+                write!(
+                    f,
+                    FormatDanglingComments::Comments { comments, indent: DanglingIndentMode::None }
+                )?;
 
                 if has_line_comment {
                     write!(f, hard_line_break())?;
@@ -999,7 +1001,18 @@ impl<'a> FormatWrite<'a> for AstNode<'a, BindingPattern<'a>> {
 
 impl<'a> FormatWrite<'a> for AstNode<'a, AssignmentPattern<'a>> {
     fn write(&self, f: &mut Formatter<'_, 'a>) -> FormatResult<()> {
-        write!(f, [self.left(), space(), "=", space(), self.right()])
+        let comments = f.context().comments().own_line_comments_before(self.right.span().start);
+        write!(
+            f,
+            [
+                FormatLeadingComments::Comments(comments),
+                self.left(),
+                space(),
+                "=",
+                space(),
+                self.right(),
+            ]
+        )
     }
 }
 
@@ -1077,6 +1090,11 @@ impl<'a> FormatWrite<'a> for AstNode<'a, BindingRestElement<'a>> {
 
 impl<'a> FormatWrite<'a> for AstNode<'a, FormalParameters<'a>> {
     fn write(&self, f: &mut Formatter<'_, 'a>) -> FormatResult<()> {
+        let comments = f.context().comments().comments_before(self.span.start);
+        if !comments.is_empty() {
+            write!(f, [space(), FormatTrailingComments::Comments(comments)])?;
+        }
+
         let parentheses_not_needed = if let AstNodes::ArrowFunctionExpression(arrow) = self.parent {
             can_avoid_parentheses(arrow, f)
         } else {
@@ -1259,15 +1277,24 @@ impl<'a> FormatWrite<'a> for AstNode<'a, MethodDefinition<'a>> {
         if let Some(type_parameters) = &self.value().type_parameters() {
             write!(f, type_parameters)?;
         }
-        write!(f, group(&self.value().params()))?;
-        if let Some(return_type) = &self.value().return_type() {
+        let value = self.value();
+        let comments = f.context().comments().comments_before(value.params().span.start);
+        if !comments.is_empty() {
+            write!(f, [space(), FormatTrailingComments::Comments(comments)])?;
+        }
+        write!(f, group(&value.params()))?;
+        if let Some(return_type) = &value.return_type() {
             write!(f, return_type)?;
         }
-        if let Some(body) = &self.value().body() {
+        if let Some(body) = &value.body() {
+            let comments = f.context().comments().block_comments_before(body.span.start);
+            if !comments.is_empty() {
+                write!(f, [space(), FormatLeadingComments::Comments(comments)])?;
+            }
             write!(f, [space(), body])?;
         }
         if self.r#type().is_abstract()
-            || matches!(self.value().r#type(), FunctionType::TSEmptyBodyFunctionExpression)
+            || matches!(value.r#type, FunctionType::TSEmptyBodyFunctionExpression)
         {
             write!(f, OptionalSemicolon)?;
         }

tasks/ast_tools/src/generators/formatter/format.rs

@@ -14,7 +14,7 @@ use crate::{
 const FORMATTER_CRATE_PATH: &str = "crates/oxc_formatter";
 
 /// Based on the prettier printing comments algorithm, these nodes don't need to print comments.
-const AST_NODE_WITHOUT_PRINTING_COMMENTS_LIST: &[&str] = &["FormalParameters"];
+const AST_NODE_WITHOUT_PRINTING_COMMENTS_LIST: &[&str] = &["FormalParameters", "FunctionBody"];
 
 const NEEDS_PARENTHESES: &[&str] = &[
     "Class",

tasks/prettier_conformance/snapshots/prettier.js.snap.md

@@ -1,4 +1,4 @@
-js compatibility: 489/699 (69.96%)
+js compatibility: 492/699 (70.39%)
 
 # Failed
 
@@ -11,7 +11,6 @@ js compatibility: 489/699 (69.96%)
 | js/assignment/issue-10218.js | 💥 | 52.63% |
 | js/assignment/issue-7572.js | 💥 | 72.73% |
 | js/assignment/sequence.js | 💥 | 71.43% |
-| js/assignment-comments/function.js | 💥 | 92.73% |
 | js/async/inline-await.js | 💥 | 25.00% |
 | js/async/nested.js | 💥 | 16.67% |
 | js/binary-expressions/inline-jsx.js | 💥 | 40.00% |
@@ -25,7 +24,6 @@ js compatibility: 489/699 (69.96%)
 | js/class-static-block/class-static-block.js | 💥 | 57.14% |
 | js/class-static-block/with-line-breaks.js | 💥 | 50.00% |
 | js/classes/assignment.js | 💥 | 81.25% |
-| js/classes/method.js | 💥 | 71.43% |
 | js/classes/property.js | 💥 | 62.86% |
 | js/classes-private-fields/with_comments.js | 💥💥 | 30.77% |
 | js/comments/15661.js | 💥💥 | 53.63% |
@@ -38,7 +36,7 @@ js compatibility: 489/699 (69.96%)
 | js/comments/empty-statements.js | 💥💥 | 90.91% |
 | js/comments/export-and-import.js | 💥💥 | 85.71% |
 | js/comments/export.js | 💥💥 | 84.93% |
-| js/comments/function-declaration.js | 💥💥 | 68.29% |
+| js/comments/function-declaration.js | 💥💥 | 91.06% |
 | js/comments/issue-3532.js | 💥💥 | 79.73% |
 | js/comments/issues.js | 💥💥 | 94.89% |
 | js/comments/jsdoc-nestled-dangling.js | 💥💥 | 93.02% |
@@ -54,7 +52,6 @@ js compatibility: 489/699 (69.96%)
 | js/comments/try.js | 💥💥 | 71.43% |
 | js/comments/variable_declarator.js | 💥✨ | 49.31% |
 | js/comments/flow-types/inline.js | 💥 | 62.50% |
-| js/comments/function/between-parentheses-and-function-body.js | 💥 | 55.17% |
 | js/comments/html-like/comment.js | 💥 | 0.00% |
 | js/comments-closure-typecast/binary-expr.js | 💥 | 0.00% |
 | js/comments-closure-typecast/closure-compiler-type-cast.js | 💥 | 66.13% |

tasks/prettier_conformance/snapshots/prettier.ts.snap.md

@@ -1,4 +1,4 @@
-ts compatibility: 247/573 (43.11%)
+ts compatibility: 248/573 (43.28%)
 
 # Failed
 
@@ -104,9 +104,8 @@ ts compatibility: 247/573 (43.11%)
 | typescript/comments/jsx.tsx | 💥 | 20.00% |
 | typescript/comments/location.ts | 💥 | 75.00% |
 | typescript/comments/mapped_types.ts | 💥 | 58.82% |
-| typescript/comments/method_types.ts | 💥 | 74.36% |
-| typescript/comments/methods.ts | 💥 | 97.96% |
-| typescript/comments/type-parameters.ts | 💥 | 40.00% |
+| typescript/comments/method_types.ts | 💥 | 76.92% |
+| typescript/comments/type-parameters.ts | 💥 | 36.36% |
 | typescript/comments/type_literals.ts | 💥 | 55.17% |
 | typescript/comments/union.ts | 💥 | 5.26% |
 | typescript/comments-2/dangling.ts | 💥💥 | 75.00% |