Stop comments that share a line from doubling each other's indent

Comment.computeBreaks moved the column past a comment by adding the
length of the comment's last line to the column the comment started at.
For a comment that spans lines, JavaCommentsHelper.rewrite has already
indented that last line to the start column, so the column was counted
twice, and each further comment on the line was re-indented from the
doubled column. Commented-out code with javadoc in it, where every
"*//** javadoc *//*" puts several multi-line comments on one line, grew
from 817 bytes to 4.3 MB with 16 of them and ran out of a 2 GB heap
with 26 (#36, from google/google-java-format#413).

After a comment that spans lines the column is now the length of its
last line; after a one-line comment it is still the start column plus
the comment. The 26 comments now format into 12.5 kB in 0.33 s, each
indented to the column where it starts.

A golden of the reported file and a test with 16 such comments fail
without the change. The 15,747 files of the JDK 21 sources format
exactly as before.

Author: abashev

open-java-format/src/main/java/com/palantir/javaformat/doc/Comment.java

@@ -88,8 +88,13 @@ public State computeBreaks(
             CommentsHelper commentsHelper, int maxWidth, State state, Obs.ExplorationNode observationNode) {
         String text = commentsHelper.rewrite(tok, maxWidth, state.column());
         @SuppressWarnings("for-rollout:NullAway")
-        int firstLineLength = text.length() - Iterators.getLast(Newlines.lineOffsetIterator(text));
-        return state.withColumn(state.column() + firstLineLength)
+        int lastLineStart = Iterators.getLast(Newlines.lineOffsetIterator(text));
+        int lastLineLength = text.length() - lastLineStart;
+        // rewrite() indents every line after the first to state.column(), so after a comment that spans lines the
+        // column is the length of its last line. Adding state.column() to it as well doubled the column for each
+        // further comment on that line.
+        int column = lastLineStart == 0 ? state.column() + lastLineLength : lastLineLength;
+        return state.withColumn(column)
                 .addNewLines(Iterators.size(Newlines.lineOffsetIterator(text)))
                 .withTokState(this, ImmutableTokState.of(text));
     }

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

@@ -491,4 +491,21 @@ void formatsDeeplyNestedCallsQuickly() {
 
         assertTimeoutPreemptively(Duration.ofSeconds(10), () -> formatter.formatSource(input));
     }
+
+    @Test
+    void indentsCommentsThatShareALineLinearly() throws FormatterException {
+        // Commented-out code that had javadoc in it puts many multi-line comments on one line: "*//** javadoc *//*".
+        // Each comment's continuation lines are indented to the column where the comment starts, and the column after
+        // a comment used to be counted from where it started plus its last line, which already holds that indent. So
+        // every comment started twice as far right as the one before, and these sixteen came out as 4.3 MB.
+        StringBuilder input = new StringBuilder("/*\nclass X {\n");
+        for (int i = 0; i < 16; i++) {
+            input.append("\t*//** javadoc *//*\n\tpublic void foo(Bar bar) {}\n\n");
+        }
+        input.append("}*/\n");
+        Formatter formatter = Formatter.createFormatter(
+                JavaFormatterOptions.builder().style(Style.OJF).build());
+
+        assertThat(formatter.formatSource(input.toString()).length()).isLessThan(10_000);
+    }
 }

open-java-format/src/test/resources/com/palantir/javaformat/java/testdata/ojf-issue-36-multiline-comments-on-one-line.input

@@ -0,0 +1,14 @@
+/*
+class X {
+	*//** javadoc *//*
+	public void foo(Bar bar) {}
+
+	*//** javadoc *//*
+	public void foo(Bar bar) {}
+
+	*//** javadoc *//*
+	public void foo(Bar bar) {}
+
+	*//** javadoc *//*
+	public void foo(Bar bar) {}
+}*/

open-java-format/src/test/resources/com/palantir/javaformat/java/testdata/ojf-issue-36-multiline-comments-on-one-line.output

@@ -0,0 +1,14 @@
+/*
+class X {
+	*//** javadoc *//*
+                 public void foo(Bar bar) {}
+
+                 *//** javadoc *//*
+                                 public void foo(Bar bar) {}
+
+                                 *//** javadoc *//*
+                                                 public void foo(Bar bar) {}
+
+                                                 *//** javadoc *//*
+                                                                 	public void foo(Bar bar) {}
+                                                                 }*/