Improve whitespace handling around partial format ranges

During partial formatting the formatter reformats entire statements, and then
splices formatted statements from the reformatted regions together
with unformatted statements from outside the reformatted regions.

Previously the whitespace between formatted and unformatted statements was
preserved from the input. This change causes the formatter to use whitespace
from the formatted file at those boundaries.

In practice, this means that the formatter does a better job of removing or
inserting blank lines around reformatted regions, and of removing trailing
whitespace from lines adjacent to reformatted regions.

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

Author: cushon

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

@@ -42,6 +42,16 @@ public static boolean isNewline(String input) {
     return BREAKS.contains(input);
   }
 
+  /** Returns the length of the newline sequence at the current offset, or {@code -1}. */
+  public static int hasNewlineAt(String input, int idx) {
+    for (String b : BREAKS) {
+      if (input.startsWith(b, idx)) {
+        return b.length();
+      }
+    }
+    return -1;
+  }
+
   /**
    * Returns the terminating line break in the input, or {@code null} if the input does not end in a
    * break.

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

@@ -145,7 +145,10 @@ public void append(String text, Range<Integer> range) {
             break;
           default:
             while (newlinesPending > 0) {
-              mutableLines.add(lineBuilder.toString());
+              // drop leading blank lines
+              if (!mutableLines.isEmpty() || lineBuilder.length() > 0) {
+                mutableLines.add(lineBuilder.toString());
+              }
               lineBuilder = new StringBuilder();
               rangesSet = false;
               --newlinesPending;
@@ -253,44 +256,33 @@ public ImmutableList<Replacement> getFormatReplacements(RangeSet<Integer> iRange
       // Add all output lines in the given token range to the replacement.
       StringBuilder replacement = new StringBuilder();
 
-      boolean needsBreakBefore = false;
       int replaceFrom = startTok.getPosition();
+      // Replace leading whitespace in the input with the whitespace from the formatted file
       while (replaceFrom > 0) {
         char previous = javaInput.getText().charAt(replaceFrom - 1);
-        if (previous == '\n' || previous == '\r') {
+        if (!CharMatcher.whitespace().matches(previous)) {
           break;
         }
-        if (CharMatcher.whitespace().matches(previous)) {
-          replaceFrom--;
-          continue;
-        }
-        needsBreakBefore = true;
-        break;
+        replaceFrom--;
       }
 
-      if (needsBreakBefore) {
-        replacement.append(lineSeparator);
+      int i = kToJ.get(startTok.getIndex()).lowerEndpoint();
+      // Include leading blank lines from the formatted output, unless the formatted range
+      // starts at the beginning of the file.
+      while (i > 0 && getLine(i - 1).isEmpty()) {
+        i--;
       }
-
-      boolean first = true;
-      int i;
-      for (i = kToJ.get(startTok.getIndex()).lowerEndpoint();
-          i < kToJ.get(endTok.getIndex()).upperEndpoint();
-          i++) {
+      // Write out the formatted range.
+      for (; i < kToJ.get(endTok.getIndex()).upperEndpoint(); i++) {
         // It's possible to run out of output lines (e.g. if the input ended with
         // multiple trailing newlines).
         if (i < getLineCount()) {
-          if (first) {
-            first = false;
-          } else {
+          if (i > 0) {
             replacement.append(lineSeparator);
           }
           replacement.append(getLine(i));
         }
       }
-      replacement.append(lineSeparator);
-
-      String trailingLine = i < getLineCount() ? getLine(i) : null;
 
       int replaceTo =
           Math.min(endTok.getPosition() + endTok.length(), javaInput.getText().length());
@@ -299,46 +291,50 @@ public ImmutableList<Replacement> getFormatReplacements(RangeSet<Integer> iRange
       if (endTok.getIndex() == javaInput.getkN() - 1) {
         replaceTo = javaInput.getText().length();
       }
-
-      // Expand the partial formatting range to include non-breaking trailing
-      // whitespace. If the range ultimately ends in a newline, then preserve
-      // whatever original text was on the next line (i.e. don't re-indent
-      // the next line after the reformatted range). However, if the partial
-      // formatting range doesn't end in a newline, then break and re-indent.
-      boolean reIndent = true;
-      OUTER:
+      // Replace trailing whitespace in the input with the whitespace from the formatted file.
+      // If the trailing whitespace in the input includes one or more line breaks, preserve the
+      // whitespace after the last newline to avoid re-indenting the line following the formatted
+      // line.
+      int newline = -1;
       while (replaceTo < javaInput.getText().length()) {
-        char endChar = javaInput.getText().charAt(replaceTo);
-        switch (endChar) {
-          case '\r':
-            if (replaceTo + 1 < javaInput.getText().length()
-                && javaInput.getText().charAt(replaceTo + 1) == '\n') {
-              replaceTo++;
-            }
-            // falls through
-          case '\n':
-            replaceTo++;
-            reIndent = false;
-            break OUTER;
-          default:
-            break;
+        char next = javaInput.getText().charAt(replaceTo);
+        if (!CharMatcher.whitespace().matches(next)) {
+          break;
         }
-        if (CharMatcher.whitespace().matches(endChar)) {
+        int newlineLength = Newlines.hasNewlineAt(javaInput.getText(), replaceTo);
+        if (newlineLength != -1) {
+          newline = replaceTo;
+          // Skip over the entire newline; don't count the second character of \r\n as a newline.
+          replaceTo += newlineLength;
+        } else {
           replaceTo++;
-          continue;
         }
-        break;
       }
-      if (reIndent && trailingLine != null) {
-        int idx = CharMatcher.whitespace().negate().indexIn(trailingLine);
-        if (idx > 0) {
-          replacement.append(trailingLine, 0, idx);
+      if (newline != -1) {
+        replaceTo = newline;
+      }
+
+      if (newline == -1) {
+        // There wasn't an existing trailing newline; add one.
+        replacement.append(lineSeparator);
+      }
+      for (; i < getLineCount(); i++) {
+        String after = getLine(i);
+        if (after.isEmpty()) {
+          // Write out trailing blank lines from the formatted output.
+          replacement.append(lineSeparator);
+        } else {
+          if (newline == -1) {
+            // If there wasn't a trailing newline in the input, indent the next line.
+            int idx = CharMatcher.whitespace().negate().indexIn(after);
+            replacement.append(after.substring(0, idx));
+          }
+          break;
         }
       }
 
       result.add(Replacement.create(replaceFrom, replaceTo, replacement.toString()));
     }
-
     return result.build();
   }
 

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

@@ -22,6 +22,7 @@
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ObjectArrays;
 import com.google.common.collect.Range;
+import java.io.IOException;
 import java.io.PrintWriter;
 import java.io.StringWriter;
 import java.nio.charset.StandardCharsets;
@@ -361,6 +362,7 @@ public void onlyPackage() throws Exception {
     String expectedOutput =
         lines(
             "package test;", //
+            "",
             "class Test {}",
             "");
     int idx = input.indexOf("test");
@@ -664,9 +666,9 @@ public void testGetFormatReplacementRanges() throws Exception {
     assertThat(replacement.getReplacementString())
         .isEqualTo(
             lines(
-                "  void f() {}", //
-                ""));
-    int replaceFrom = input.indexOf("void f");
+                "", //
+                "  void f() {}"));
+    int replaceFrom = input.indexOf("void f") - newline.length();
     assertThat(replacement.getReplaceRange().lowerEndpoint()).isEqualTo(replaceFrom);
   }
 
@@ -1546,4 +1548,157 @@ public void endOfLineStatementNewline() throws Exception {
             new Formatter().formatSource(in, ImmutableList.of(Range.closedOpen(idx + 1, idx + 1))))
         .isEqualTo(in);
   }
+
+  @Test
+  public void importNewlines() throws Exception {
+    String input =
+        lines(
+            "package p;",
+            "import java.util.ArrayList;",
+            "class Foo {",
+            "  ArrayList<String> xs = new ArrayList<>();",
+            "}",
+            "");
+    String expectedOutput =
+        lines(
+            "package p;",
+            "",
+            "import java.util.ArrayList;",
+            "",
+            "class Foo {",
+            "  ArrayList<String> xs = new ArrayList<>();",
+            "}",
+            "");
+
+    String output = runFormatter(input, new String[] {"-lines", "2"});
+    assertThat(output).isEqualTo(expectedOutput);
+  }
+
+  @Test
+  public void b36458607() throws Exception {
+    String input =
+        lines(
+            "// copyright",
+            "",
+            "package p;",
+            "import static c.g.I.c;",
+            "",
+            "/** */",
+            "class Foo {{ c(); }}",
+            "");
+    String expectedOutput =
+        lines(
+            "// copyright",
+            "",
+            "package p;",
+            "",
+            "import static c.g.I.c;",
+            "",
+            "/** */",
+            "class Foo {{ c(); }}",
+            "");
+
+    String output = runFormatter(input, new String[] {"-lines", "4"});
+    assertThat(output).isEqualTo(expectedOutput);
+  }
+
+  @Test
+  public void b32159971() throws Exception {
+    String input =
+        lines(
+            "", //
+            "",
+            "package p;",
+            "class X {}",
+            "");
+    String expectedOutput =
+        lines(
+            "package p;", //
+            "",
+            "class X {}",
+            "");
+
+    String output = runFormatter(input, new String[] {"-lines", "3"});
+    assertThat(output).isEqualTo(expectedOutput);
+  }
+
+  @Test
+  public void b21668189() throws Exception {
+    String input =
+        lines(
+            "class Foo {", //
+            "  {",
+            "    int x = 1;",
+            "    ",
+            "    int y = 2;",
+            "  }",
+            "}",
+            "");
+    String expectedOutput =
+        lines(
+            "class Foo {", //
+            "  {",
+            "    int x = 1;",
+            "",
+            "    int y = 2;",
+            "  }",
+            "}",
+            "");
+
+    String output = runFormatter(input, new String[] {"-lines", "4:5"});
+    assertThat(output).isEqualTo(expectedOutput);
+  }
+
+  private String runFormatter(String input, String[] args) throws IOException, UsageException {
+    Path tmpdir = testFolder.newFolder().toPath();
+    Path path = tmpdir.resolve("Foo.java");
+    Files.write(path, input.getBytes(StandardCharsets.UTF_8));
+
+    StringWriter out = new StringWriter();
+    StringWriter err = new StringWriter();
+
+    Main main = new Main(new PrintWriter(out, true), new PrintWriter(err, true), System.in);
+    assertThat(main.format(ObjectArrays.concat(args, path.toString()))).isEqualTo(0);
+    return out.toString();
+  }
+
+  @Test
+  public void trailing() throws Exception {
+    String input =
+        lines(
+            "package foo.bar.baz;",
+            "",
+            "public class B {",
+            "  public void f() {",
+            "    int a = 7 +4;",
+            "    int b = 7 +4;",
+            "    int c = 7 +4;",
+            "    int d = 7 +4;",
+            "",
+            "    int e = 7 +4;",
+            "  }",
+            "}");
+    String expected =
+        lines(
+            "package foo.bar.baz;",
+            "",
+            "public class B {",
+            "  public void f() {",
+            "    int a = 7 +4;",
+            "    int b = 7 +4;",
+            "    int c = 7 + 4;",
+            "    int d = 7 +4;",
+            "",
+            "    int e = 7 +4;",
+            "  }",
+            "}");
+    String actual =
+        new Formatter().formatSource(input, ImmutableList.of(rangeOf(input, "int c = 7 +4")));
+    assertThat(actual).isEqualTo(expected);
+  }
+
+  private Range<Integer> rangeOf(String input, String needle) {
+    int idx = input.indexOf(needle);
+    return Range.closedOpen(idx, idx + needle.length());
+  }
 }