Stop splitting long strings inside an escaped backslash

StringWrapper cuts a long string literal before whitespace and before
\t, and ends a piece after \n and \r, but never asked whether the
backslash of such an escape is escaped itself. In 'D:\\tempDb' the
second backslash and the t looked like a tab, so a line break there
left a lone backslash that escaped the closing quote, and the file
failed with "unclosed string literal" (#32, from
palantir#1680). \\n and \\r were misread the same
way: they cut words such as C:\\new in two and forced a line break,
which moved the break but still parsed.

A backslash with an odd number of backslashes right before it now
counts as escaped, both where pieces are cut and where a piece forces
the line to end. Literals without an escaped backslash are cut as
before. Of the JDK 21 and 25 sources, the same 8 files format
differently: resource bundles whose messages contain \\n or \\r, which
no longer break the line after them.

Author: abashev

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

@@ -432,7 +432,7 @@ private static ImmutableList<String> stringComponents(
     }
 
     static int hasEscapedWhitespaceAt(String input, int idx) {
-        if (input.startsWith("\\t", idx)) {
+        if (input.startsWith("\\t", idx) && !isEscaped(input, idx)) {
             return 2;
         }
         return -1;
@@ -446,7 +446,19 @@ static int hasEscapedNewlineAt(String input, int idx) {
         if (input.startsWith("\\n", idx)) {
             offset += 2;
         }
-        return offset > 0 ? offset : -1;
+        return offset > 0 && !isEscaped(input, idx) ? offset : -1;
+    }
+
+    /**
+     * Whether the character at {@code idx} is escaped by the backslashes before it. In {@code \\t} the second backslash
+     * is, so it starts no escape sequence of its own and the {@code t} is an ordinary letter.
+     */
+    private static boolean isEscaped(String input, int idx) {
+        int backslashes = 0;
+        while (idx - backslashes > 0 && input.charAt(idx - backslashes - 1) == '\\') {
+            backslashes++;
+        }
+        return backslashes % 2 == 1;
     }
 
     /**
@@ -486,7 +498,7 @@ private static String reflow(
                 String text = input.removeFirst();
                 line.add(text);
                 length += text.length();
-                if (text.endsWith("\\n") || text.endsWith("\\r")) {
+                if (hasEscapedNewlineAt(text, text.length() - 2) != -1) {
                     break;
                 }
             }

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

@@ -15,8 +15,23 @@
 package com.palantir.javaformat.java;
 
 import static com.google.common.truth.Truth.assertThat;
+import static com.palantir.javaformat.java.JavaFormatterOptions.Style;
 
 import com.google.common.base.Joiner;
+import com.google.common.collect.Iterables;
+import com.sun.source.tree.BinaryTree;
+import com.sun.source.tree.ClassTree;
+import com.sun.source.tree.CompilationUnitTree;
+import com.sun.source.tree.ExpressionTree;
+import com.sun.source.tree.LiteralTree;
+import com.sun.source.tree.VariableTree;
+import com.sun.source.util.JavacTask;
+import java.io.IOException;
+import java.net.URI;
+import java.util.List;
+import javax.tools.JavaFileObject;
+import javax.tools.SimpleJavaFileObject;
+import javax.tools.ToolProvider;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.parallel.Execution;
 import org.junit.jupiter.api.parallel.ExecutionMode;
@@ -48,6 +63,60 @@ public void testAwkwardLineEndWrapping() throws Exception {
         assertThat(StringWrapper.wrap(100, input, Formatter.create())).isEqualTo(output);
     }
 
+    @Test
+    public void wrapsAStringWithEscapedBackslashes() throws Exception {
+        // In D:\\tempDb the second backslash and the t are not an escaped tab. Splitting there left a lone backslash
+        // at the end of a piece, where it escaped the closing quote.
+        String input = lines(
+                "class C {",
+                "    void m(java.sql.Connection con) throws Exception {",
+                "        con.createStatement()",
+                "                .execute(\"ALTER DATABASE tempdb MODIFY FILE (NAME = 'tempdev',"
+                        + " FILENAME = 'D:\\\\tempDb\\\\DATA\\\\tempdb.mdf')\");",
+                "    }",
+                "}");
+        Formatter formatter = Formatter.createFormatter(
+                JavaFormatterOptions.builder().style(Style.OJF).build());
+
+        String output = formatter.formatSourceAndFixImports(input);
+
+        assertThat(formatter.formatSourceAndFixImports(output)).isEqualTo(output);
+    }
+
+    @Test
+    public void wrappingKeepsTheValueOfAStringWithEscapes() throws Exception {
+        // At 40 columns the first line fills up right inside C:\\temp, where \\t is not an escaped tab.
+        String input = lines("class T {", "  String s = \"copy the file to C:\\\\temp and back\";", "}");
+
+        String output = StringWrapper.wrap(40, input, Formatter.create());
+
+        assertThat(output).isNotEqualTo(input);
+        assertThat(stringValue(output)).isEqualTo(stringValue(input));
+    }
+
+    /** The value javac gives the initializer of the only field: a string literal, or literals joined with +. */
+    private static String stringValue(String source) throws IOException {
+        JavaFileObject file = new SimpleJavaFileObject(URI.create("string:///T.java"), JavaFileObject.Kind.SOURCE) {
+            @Override
+            public CharSequence getCharContent(boolean ignoreEncodingErrors) {
+                return source;
+            }
+        };
+        JavacTask task =
+                (JavacTask) ToolProvider.getSystemJavaCompiler().getTask(null, null, null, null, null, List.of(file));
+        CompilationUnitTree unit = Iterables.getOnlyElement(task.parse());
+        ClassTree type = (ClassTree) Iterables.getOnlyElement(unit.getTypeDecls());
+        VariableTree field = (VariableTree) Iterables.getOnlyElement(type.getMembers());
+        return concatenation(field.getInitializer());
+    }
+
+    private static String concatenation(ExpressionTree expression) {
+        if (expression instanceof BinaryTree plus) {
+            return concatenation(plus.getLeftOperand()) + concatenation(plus.getRightOperand());
+        }
+        return (String) ((LiteralTree) expression).getValue();
+    }
+
     private static String lines(String... line) {
         return Joiner.on('\n').join(line) + '\n';
     }

open-java-format/src/test/resources/com/palantir/javaformat/java/StringWrapperIntegrationTest/16.input

@@ -0,0 +1,3 @@
+class T {
+  String s = "fields split on \\t, lines on \\r\\n or \\n in C:\\temp\\new\\reports and \\\\server\\share for caf\u00e9\tthen\ndone";
+}

open-java-format/src/test/resources/com/palantir/javaformat/java/StringWrapperIntegrationTest/16.output

@@ -0,0 +1,8 @@
+class T {
+  String s = "fields split on \\t,"
+      + " lines on \\r\\n or \\n in"
+      + " C:\\temp\\new\\reports and"
+      + " \\\\server\\share for"
+      + " caf\u00e9\tthen\n"
+      + "done";
+}