google-java-formatter: reformat portions of the text affected by reflowing

-------------
Created by MOE: https://github.com/google/moe
MOE_MIGRATED_REVID=263545728

Author: awturner

core/src/main/java/com/google/googlejavaformat/java/FormatFileCallable.java

@@ -41,11 +41,11 @@ public String call() throws FormatterException {
       return fixImports(input);
     }
 
-    String formatted =
-        new Formatter(options).formatSource(input, characterRanges(input).asRanges());
+    Formatter formatter = new Formatter(options);
+    String formatted = formatter.formatSource(input, characterRanges(input).asRanges());
     formatted = fixImports(formatted);
     if (parameters.reflowLongStrings()) {
-      formatted = StringWrapper.wrap(Formatter.MAX_LINE_LENGTH, formatted);
+      formatted = StringWrapper.wrap(Formatter.MAX_LINE_LENGTH, formatted, formatter);
     }
     return formatted;
   }

core/src/main/java/com/google/googlejavaformat/java/Formatter.java

@@ -219,7 +219,7 @@ public String formatSourceAndFixImports(String input) throws FormatterException
     input = ImportOrderer.reorderImports(input, options.style());
     input = RemoveUnusedImports.removeUnusedImports(input);
     String formatted = formatSource(input);
-    formatted = StringWrapper.wrap(formatted);
+    formatted = StringWrapper.wrap(formatted, this);
     return formatted;
   }
 

core/src/main/java/com/google/googlejavaformat/java/StringWrapper.java

@@ -62,19 +62,52 @@
 /** Wraps string literals that exceed the column limit. */
 public final class StringWrapper {
   /** Reflows long string literals in the given Java source code. */
-  public static String wrap(String input) throws FormatterException {
-    return StringWrapper.wrap(Formatter.MAX_LINE_LENGTH, input);
+  public static String wrap(String input, Formatter formatter) throws FormatterException {
+    return StringWrapper.wrap(Formatter.MAX_LINE_LENGTH, input, formatter);
   }
 
   /**
    * Reflows string literals in the given Java source code that extend past the given column limit.
    */
-  static String wrap(final int columnLimit, final String input) throws FormatterException {
+  static String wrap(final int columnLimit, String input, Formatter formatter)
+      throws FormatterException {
     if (!longLines(columnLimit, input)) {
       // fast path
       return input;
     }
 
+    TreeRangeMap<Integer, String> replacements = getReflowReplacements(columnLimit, input);
+    String firstPass = formatter.formatSource(input, replacements.asMapOfRanges().keySet());
+
+    if (!firstPass.equals(input)) {
+      // If formatting the replacement ranges resulted in a change, recalculate the replacements on
+      // the updated input.
+      input = firstPass;
+      replacements = getReflowReplacements(columnLimit, input);
+    }
+
+    String result = applyReplacements(input, replacements);
+
+    {
+      // We really don't want bugs in this pass to change the behaviour of programs we're
+      // formatting, so check that the pretty-printed AST is the same before and after reformatting.
+      String expected = parse(input, /* allowStringFolding= */ true).toString();
+      String actual = parse(result, /* allowStringFolding= */ true).toString();
+      if (!expected.equals(actual)) {
+        throw new FormatterException(
+            String.format(
+                "Something has gone terribly wrong. Please file a bug: "
+                    + "https://github.com/google/google-java-format/issues/new"
+                    + "\n\n=== Actual: ===\n%s\n=== Expected: ===\n%s\n",
+                actual, expected));
+      }
+    }
+
+    return result;
+  }
+
+  private static TreeRangeMap<Integer, String> getReflowReplacements(
+      int columnLimit, final String input) throws FormatterException {
     JCTree.JCCompilationUnit unit = parse(input, /* allowStringFolding= */ false);
     String separator = Newlines.guessLineSeparator(input);
 
@@ -137,24 +170,7 @@ public Void visitLiteral(LiteralTree literalTree, Void aVoid) {
           Range.closedOpen(getStartPosition(flat.get(0)), getEndPosition(unit, getLast(flat))),
           reflow(separator, columnLimit, startColumn, trailing, components, first.get()));
     }
-    String result = applyReplacements(input, replacements);
-
-    {
-      // We really don't want bugs in this pass to change the behaviour of programs we're
-      // formatting, so check that the pretty-printed AST is the same before and after reformatting.
-      String expected = parse(input, /* allowStringFolding= */ true).toString();
-      String actual = parse(result, /* allowStringFolding= */ true).toString();
-      if (!expected.equals(actual)) {
-        throw new FormatterException(
-            String.format(
-                "Something has gone terribly wrong. Please file a bug: "
-                    + "https://github.com/google/google-java-format/issues/new"
-                    + "\n\n=== Actual: ===\n%s\n=== Expected: ===\n%s\n",
-                actual, expected));
-      }
-    }
-
-    return result;
+    return replacements;
   }
 
   /**

core/src/test/java/com/google/googlejavaformat/java/StringWrapperIntegrationTest.java

@@ -378,6 +378,8 @@ public static Collection<Object[]> parameters() {
         .collect(toImmutableList());
   }
 
+  private final Formatter formatter = new Formatter();
+
   private final String input;
   private final String output;
 
@@ -388,24 +390,25 @@ public StringWrapperIntegrationTest(String input, String output) {
 
   @Test
   public void test() throws Exception {
-    assertThat(StringWrapper.wrap(40, new Formatter().formatSource(input))).isEqualTo(output);
+    assertThat(StringWrapper.wrap(40, formatter.formatSource(input), formatter)).isEqualTo(output);
   }
 
   @Test
   public void testCR() throws Exception {
-    assertThat(StringWrapper.wrap(40, new Formatter().formatSource(input.replace("\n", "\r"))))
+    assertThat(StringWrapper.wrap(40, formatter.formatSource(input.replace("\n", "\r")), formatter))
         .isEqualTo(output.replace("\n", "\r"));
   }
 
   @Test
   public void testCRLF() throws Exception {
-    assertThat(StringWrapper.wrap(40, new Formatter().formatSource(input.replace("\n", "\r\n"))))
+    assertThat(
+            StringWrapper.wrap(40, formatter.formatSource(input.replace("\n", "\r\n")), formatter))
         .isEqualTo(output.replace("\n", "\r\n"));
   }
 
   @Test
   public void idempotent() throws Exception {
-    String wrap = StringWrapper.wrap(40, new Formatter().formatSource(input));
-    assertThat(wrap).isEqualTo(new Formatter().formatSource(wrap));
+    String wrap = StringWrapper.wrap(40, formatter.formatSource(input), formatter);
+    assertThat(wrap).isEqualTo(formatter.formatSource(wrap));
   }
 }

core/src/test/java/com/google/googlejavaformat/java/StringWrapperTest.java

@@ -0,0 +1,44 @@
+package com.google.googlejavaformat.java;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import com.google.common.base.Joiner;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** {@link StringWrapper}Test */
+@RunWith(JUnit4.class)
+public class StringWrapperTest {
+  @Test
+  public void testAwkwardLineEndWrapping() throws Exception {
+    String input =
+        lines(
+            "class T {",
+            // This is a wide line, but has to be split in code because of 100-char limit.
+            "  String s = someMethodWithQuiteALongNameThatWillGetUsUpCloseToTheColumnLimit() "
+                + "+ \"foo bar foo bar foo bar\";",
+            "",
+            "  String someMethodWithQuiteALongNameThatWillGetUsUpCloseToTheColumnLimit() {",
+            "    return null;",
+            "  }",
+            "}");
+    String output =
+        lines(
+            "class T {",
+            "  String s =",
+            "      someMethodWithQuiteALongNameThatWillGetUsUpCloseToTheColumnLimit()",
+            "          + \"foo bar foo bar foo bar\";",
+            "",
+            "  String someMethodWithQuiteALongNameThatWillGetUsUpCloseToTheColumnLimit() {",
+            "    return null;",
+            "  }",
+            "}");
+
+    assertThat(StringWrapper.wrap(100, input, new Formatter())).isEqualTo(output);
+  }
+
+  private static String lines(String... line) {
+    return Joiner.on('\n').join(line) + '\n';
+  }
+}