Fix unstable formatting of trailing callback comments

Signed-off-by: Christoph Knittel <ck@cca.io>

Author: cknitt

CHANGELOG.md

@@ -35,6 +35,8 @@
 
 #### :bug: Bug fix
 
+- Fix unstable formatting of trailing comments in nested callbacks. https://github.com/rescript-lang/rescript/issues/6976
+
 - Fix excessive parentheses and indentation in function assignments to refs, align record and array assignment formatting across refs and fields, and preserve function return-type parentheses and consistent JSX fragment layout in callbacks. https://github.com/rescript-lang/rescript/pull/8611
 - Fix a recursive module with an empty signature discarding its right-hand side. Lambda-to-Lam conversion rewrote `Pupdate_mod` to unit when the module's shape had no fields, dropping the primitive's arguments - one of which is the right-hand side - so `module rec M: {} = { let () = Console.log("effect") }` emitted nothing for `M`. The elision now happens where the bindings are produced, with the right-hand side still in hand. https://github.com/rescript-lang/rescript/pull/8608
 - Fix `Int.Ref.increment` and `Int.Ref.decrement` evaluating their argument twice: `Int.Ref.increment(mkRef())` emitted `mkRef().contents = mkRef().contents + 1 | 0`. The `%incr` and `%decr` builtins lowered to an assignment that repeated the argument expression; they now bind the reference before the read-modify-write. Inlining decisions around an increment are taken on the code it stands for rather than on a single primitive node. https://github.com/rescript-lang/rescript/pull/8608

compiler/syntax/src/res_printer.ml

@@ -4657,14 +4657,28 @@ and print_pexp_apply ~state expr cmt_tbl =
       | Braced braces -> print_braces doc call_expr braces
       | Nothing -> doc
     in
-    if Parsetree_viewer.requires_special_callback_printing_first_arg args then
+    (* Use the regular argument layout for trailing comments. Compact callback
+     * layouts can detach comments from the body when it breaks, making
+     * subsequent formatting unstable. *)
+    let args_have_trailing_comments =
+      List.exists
+        (fun (_, (arg : Parsetree.expression)) ->
+          has_trailing_comments cmt_tbl arg.pexp_loc)
+        args
+    in
+    if
+      (not args_have_trailing_comments)
+      && Parsetree_viewer.requires_special_callback_printing_first_arg args
+    then
       let args_doc =
         print_arguments_with_callback_in_first_position ~state ~partial args
           cmt_tbl
       in
       Doc.concat
         [print_attributes ~state attrs cmt_tbl; call_expr_doc; args_doc]
-    else if Parsetree_viewer.requires_special_callback_printing_last_arg args
+    else if
+      (not args_have_trailing_comments)
+      && Parsetree_viewer.requires_special_callback_printing_last_arg args
     then
       let args_doc =
         print_arguments_with_callback_in_last_position ~state ~partial args

tests/syntax_tests/data/printer/comments/callbackTrailing.res

@@ -0,0 +1,34 @@
+let rec fib = (n, k) =>
+  switch n {
+  | 0 | 1 => k(1)
+  | _ =>
+    Suspend(
+      () =>
+        fib(n - 1, (v0) =>
+          fib(n - 2, (v1) =>
+            k(v0 + v1)
+            /* comment */
+          )
+        ),
+    )
+  }
+
+let first = call(x => x
+  /* first callback */
+, value)
+
+let last = call(value, x => x
+  // last callback
+)
+
+let inline = call(value, x => x // inline callback
+)
+
+let firstInline = call(x => x // first inline callback
+, value)
+
+let nested = call(value, x => call(value, y => y
+  /* nested callback */
+))
+
+let blocks = call(value, x => x /* inline block */)

tests/syntax_tests/data/printer/comments/expected/callbackTrailing.res.txt

@@ -0,0 +1,41 @@
+let rec fib = (n, k) =>
+  switch n {
+  | 0 | 1 => k(1)
+  | _ =>
+    Suspend(
+      () =>
+        fib(n - 1, v0 =>
+          fib(
+            n - 2,
+            v1 => k(v0 + v1),
+            /* comment */
+          )
+        ),
+    )
+  }
+
+let first = call(
+  x => x,
+  /* first callback */
+  value,
+)
+
+let last = call(
+  value,
+  x => x,
+  // last callback
+)
+
+let inline = call(value, x => x) // inline callback
+
+let firstInline = call(x => x, value) // first inline callback
+
+let nested = call(value, x =>
+  call(
+    value,
+    y => y,
+    /* nested callback */
+  )
+)
+
+let blocks = call(value, x => x /* inline block */)

tests/syntax_tests/res_test.ml

@@ -28,6 +28,27 @@ let x: int
 
 let () = print_endline "✅ multi printer api tests"
 
+let () =
+  let filename =
+    Filename.concat data_dir "printer/comments/callbackTrailing.res"
+  in
+  let source = IO.read_file ~filename in
+  let format ~width source =
+    let result =
+      Res_driver.parse_implementation_from_source ~for_printer:true
+        ~display_filename:filename ~source
+    in
+    assert (not result.invalid);
+    Res_printer.print_implementation ~width result.parsetree
+      ~comments:result.comments
+  in
+  List.iter
+    (fun width ->
+      let printed = format ~width source in
+      assert (printed = format ~width printed))
+    [20; 40; 80; 100; 120];
+  print_endline "✅ callback trailing comments are stable at multiple widths"
+
 module Outcome_printer_tests = struct
   let signature_to_outcome structure =
     Lazy.force Res_outcome_printer.setup;