Indent a block comment that trails { like the statements after it

A `/* ... */` comment left on the line of an opening brace is moved onto its
own line, and landed one indent deeper than the statements of the block, or
the elements of the array initializer, that followed it. A second run moved
it back, so the output was not stable. A lambda body such as
`() -> { /* c */ f(); }` and a block after `default:` had the same defect.

visitBlock and the non-empty branch of visitArrayInitializer open a plusTwo
level and then asked for another plusTwo on the break before the comment.
OpsBuilder.build puts that comment right after the token, inside the level,
so the two indents stacked. The break now gets ZERO there. An empty block
keeps plusTwo: it closes the level right after `{`, and build moves the
comment past that close, so without the indent the comment would sit at the
column of the braces.

Ported from google/google-java-format#1464 (commit ea7b0c40), which fixes
google/google-java-format#1260. The tests were written first: the I1260
fixture (upstream's input plus a lambda body) and
trailingCommentAfterOpenBraceIsIdempotent in GOOGLE style failed on the
first pass before the change. The I1260EmptyBlocks fixture pins the
empty-block shapes that the change leaves as they were.

Fixes #129.

Author: tanvir-ux

open-java-format/src/main/java/com/palantir/javaformat/java/JavaInputAstVisitor.java

@@ -541,7 +541,8 @@ public boolean visitArrayInitializer(List<? extends ExpressionTree> expressions)
 
             builder.open(ZERO, BreakBehaviour.breakThisLevel(), LastLevelBreakability.ACCEPT_INLINE_CHAIN);
             builder.open(plusTwo, BreakBehaviour.breakThisLevel(), LastLevelBreakability.ACCEPT_INLINE_CHAIN);
-            tokenBreakTrailingComment("{", plusTwo);
+            // Same as visitBlock: the break is already inside the plusTwo level, and this branch has elements.
+            tokenBreakTrailingComment("{", ZERO);
             boolean hasTrailingComma = hasTrailingToken(builder.getInput(), expressions, ",");
             builder.breakOp(hasTrailingComma ? FillMode.FORCED : FillMode.UNIFIED, "", ZERO);
             if (allowFilledElementsOnOwnLine) {
@@ -2154,7 +2155,11 @@ protected void visitBlock(
         } else {
             builder.open(ZERO);
             builder.open(plusTwo);
-            tokenBreakTrailingComment("{", plusTwo);
+            // OpsBuilder.build puts a comment that trails "{" right after the token, inside the plusTwo level, so a
+            // non-empty block adds no indent of its own: the comment lines up with the statements, and a second run
+            // leaves it there. An empty block closes the level right after "{", and build moves the comment past that
+            // close, so it keeps plusTwo to sit inside the braces.
+            tokenBreakTrailingComment("{", node.getStatements().isEmpty() ? plusTwo : ZERO);
             if (allowLeadingBlankLine == AllowLeadingBlankLine.NO) {
                 builder.blankLineWanted(BlankLineWanted.NO);
             } else {

open-java-format/src/test/java/com/palantir/javaformat/java/FormatterTest.java

@@ -636,4 +636,40 @@ void f(Map<String, Integer> map) {
 
         assertThat(formatter.formatSource(input)).isEqualTo(input);
     }
+
+    @Test
+    void trailingCommentAfterOpenBraceIsIdempotent() throws FormatterException {
+        // A block comment that trails `{` is broken onto its own line. It used to land one indent deeper than the
+        // statements that follow, and only a second run moved it back (google-java-format#1260, #129).
+        String input = """
+            class T {
+              void f() {
+                { /* c */ int x = 1; }
+              }
+
+              int[] a = { /* c */ 1 };
+            }
+            """;
+        String expected = """
+            class T {
+              void f() {
+                {
+                  /* c */
+                  int x = 1;
+                }
+              }
+
+              int[] a = {
+                /* c */
+                1
+              };
+            }
+            """;
+        Formatter formatter = Formatter.createFormatter(
+                JavaFormatterOptions.builder().style(Style.GOOGLE).build());
+
+        String once = formatter.formatSource(input);
+        assertThat(once).isEqualTo(expected);
+        assertThat(formatter.formatSource(once)).isEqualTo(once);
+    }
 }

open-java-format/src/test/resources/com/palantir/javaformat/java/testdata/I1260.input

@@ -0,0 +1,18 @@
+class I1260 {
+  void block() {
+    { /* trailing on open brace */ int x = 1; }
+  }
+
+  void switchCase() {
+    switch (0) {
+      case 1: { /* Break so we don't hit fall-through warning: */ break;/* ignore STRING */
+      }
+    }
+  }
+
+  void lambda() {
+    Runnable r = () -> { /* trailing on lambda brace */ block(); };
+  }
+
+  int[] array = { /* trailing on array brace */ 1, 2 };
+}

open-java-format/src/test/resources/com/palantir/javaformat/java/testdata/I1260.output

@@ -0,0 +1,29 @@
+class I1260 {
+    void block() {
+        {
+            /* trailing on open brace */
+            int x = 1;
+        }
+    }
+
+    void switchCase() {
+        switch (0) {
+            case 1: {
+                /* Break so we don't hit fall-through warning: */
+                break; /* ignore STRING */
+            }
+        }
+    }
+
+    void lambda() {
+        Runnable r = () -> {
+            /* trailing on lambda brace */
+            block();
+        };
+    }
+
+    int[] array = {
+        /* trailing on array brace */
+        1, 2
+    };
+}

open-java-format/src/test/resources/com/palantir/javaformat/java/testdata/I1260EmptyBlocks.input

@@ -0,0 +1,13 @@
+class I1260EmptyBlocks {
+  void f() {
+    { /* c */ }
+    try { /* t */ } catch (Exception e) { /* c */ }
+    try { /* t */ } finally { /* f */ }
+    if (true) { /* i */ }
+    while (true) { /* w */ }
+    switch (0) { case 1: { /* s */ } }
+    int[] a = { /* a */ };
+  }
+  void g() { /* body */ }
+  void h() { /* body */ int x; }
+}

open-java-format/src/test/resources/com/palantir/javaformat/java/testdata/I1260EmptyBlocks.output

@@ -0,0 +1,40 @@
+class I1260EmptyBlocks {
+    void f() {
+        {
+            /* c */
+        }
+        try {
+            /* t */
+        } catch (Exception e) {
+            /* c */
+        }
+        try {
+            /* t */
+        } finally {
+            /* f */
+        }
+        if (true) {
+            /* i */
+        }
+        while (true) {
+            /* w */
+        }
+        switch (0) {
+            case 1: {
+                /* s */
+            }
+        }
+        int[] a = {
+            /* a */
+        };
+    }
+
+    void g() {
+        /* body */
+    }
+
+    void h() {
+        /* body */
+        int x;
+    }
+}