reachability metadata

crogoz · crogoz · commit 2730c6413fe3 · 2025-09-22T15:52:18.000+02:00
diff --git a/palantir-java-format-jdk-bootstrap/src/main/java/com/palantir/javaformat/bootstrap/NativeImageFormatterService.java b/palantir-java-format-jdk-bootstrap/src/main/java/com/palantir/javaformat/bootstrap/NativeImageFormatterService.java
@@ -61,7 +61,8 @@ public ImmutableList<Replacement> getFormatReplacements(String input, Collection
             }
             return MAPPER.readValue(output.get(), new TypeReference<>() {});
         } catch (IOException e) {
-            throw new UncheckedIOException(String.format("Error running the native image command %s", output), e);
+            throw new UncheckedIOException(
+                    String.format("Error running the native image command; received output: %s", output), e);
         }
     }
 
diff --git a/palantir-java-format-native/src/main/resources/META-INF/native-image/reachability-metadata.json b/palantir-java-format-native/src/main/resources/META-INF/native-image/reachability-metadata.json
@@ -50,6 +50,18 @@
       "type": "com.google.common.collect.RegularImmutableList",
       "allDeclaredFields": true
     },
+    {
+      "type": "java.util.ImmutableCollections$AbstractImmutableList",
+      "allDeclaredFields": true
+    },
+    {
+      "type": "java.util.ImmutableCollections$AbstractImmutableCollection",
+      "allDeclaredFields": true
+    },
+    {
+      "type": "java.util.ImmutableCollections$List12",
+      "allDeclaredFields": true
+    },
     {
       "type": "com.google.common.collect.SingletonImmutableList",
       "allDeclaredFields": true
diff --git a/palantir-java-format/src/main/java/com/palantir/javaformat/doc/Token.java b/palantir-java-format/src/main/java/com/palantir/javaformat/doc/Token.java
@@ -24,11 +24,13 @@
 import com.palantir.javaformat.Input;
 import com.palantir.javaformat.Op;
 import com.palantir.javaformat.Output;
+import com.palantir.javaformat.java.StringWrapper;
 import java.util.Optional;
 
 /** A leaf {@link Doc} for a token. */
 @Immutable
 public final class Token extends Doc implements Op {
+
     /** Is a Token a real token, or imaginary (e.g., a token generated incorrectly, or an EOF)? */
     public enum RealOrImaginary {
         REAL,
@@ -104,13 +106,12 @@ public void add(DocBuilder builder) {
         builder.add(this);
     }
 
-    // TODO(crogoz): this is where the token gets computed. I need to differentiate between multiLine Strings and single
     // Strings
     @Override
     protected float computeWidth() {
-        if (token.getTok().getOriginalText().startsWith("\"\"\"")) {
+        if (token.getTok().getOriginalText().startsWith(StringWrapper.TEXT_BLOCK_DELIMITER)) {
             // hack hack hack to not consider the size of the textBlock such that we won't break
-            return 0;
+            return StringWrapper.TEXT_BLOCK_DELIMITER.length();
         }
         return token.getTok().length();
     }
@@ -129,9 +130,9 @@ protected Range<Integer> computeRange() {
     public State computeBreaks(
             CommentsHelper commentsHelper, int maxWidth, State state, Obs.ExplorationNode observationNode) {
         String text = token.getTok().getOriginalText();
-        if (token.getTok().getOriginalText().startsWith("\"\"\"")) {
+        if (token.getTok().getOriginalText().startsWith(StringWrapper.TEXT_BLOCK_DELIMITER)) {
             // hack hack hack to not consider the size of the textBlock such that we won't break
-            return state.withColumn(state.column() + 3);
+            return state.withColumn(state.column() + StringWrapper.TEXT_BLOCK_DELIMITER.length());
         }
         return state.withColumn(state.column() + text.length());
     }
diff --git a/palantir-java-format/src/main/java/com/palantir/javaformat/java/FormatFileCallable.java b/palantir-java-format/src/main/java/com/palantir/javaformat/java/FormatFileCallable.java
@@ -30,13 +30,12 @@
 import java.util.List;
 import java.util.Set;
 import java.util.concurrent.Callable;
-import java.util.logging.Logger;
 
 /** Encapsulates information about a file to be formatted, including which parts of the file to format. */
 class FormatFileCallable implements Callable<String> {
     private static final ObjectMapper MAPPER =
             JsonMapper.builder().addModule(new GuavaModule()).build();
-    private static final Logger log = Logger.getLogger("FormatFileCallable");
+
     private final String input;
     private final CommandLineOptions parameters;
     private final JavaFormatterOptions options;
@@ -55,12 +54,12 @@ public String call() throws FormatterException {
 
         Formatter formatter = Formatter.createFormatter(options);
         if (parameters.outputReplacements()) {
-            Set<Range<Integer>> rangesToChange = characterRanges(input).asRanges();
+            RangeSet<Integer> characterRanges = characterRanges(input);
+            Set<Range<Integer>> rangesToChange = characterRanges.asRanges();
             List<Replacement> replacements = formatter.getFormatReplacements(input, rangesToChange);
-            // log.severe("rangesToChange: " + rangesToChange);
             if (parameters.reflowLongStrings()) {
                 String formattedText = applyReplacements(input, replacements);
-                if (!StringWrapper.needWrapping(options.maxLineLength(), formattedText)) {
+                if (!StringWrapper.linesNeedWrapping(options.maxLineLength(), formattedText, characterRanges)) {
                     return writeFormatReplacements(replacements);
                 }
                 String formattedSource = StringWrapper.wrap(options.maxLineLength(), formattedText, formatter);
diff --git a/palantir-java-format/src/main/java/com/palantir/javaformat/java/JavaInputAstVisitor.java b/palantir-java-format/src/main/java/com/palantir/javaformat/java/JavaInputAstVisitor.java
@@ -2798,7 +2798,6 @@ private void visitRegularDot(List<ExpressionTree> items, boolean needDot) {
         int length = needDot0 ? minLength : 0;
         for (ExpressionTree e : items) {
             if (needDot) {
-                // Don't add a break after a text block
                 if (length > minLength) {
                     builder.breakOp(Break.builder()
                             .fillMode(FillMode.UNIFIED)
diff --git a/palantir-java-format/src/main/java/com/palantir/javaformat/java/StringWrapper.java b/palantir-java-format/src/main/java/com/palantir/javaformat/java/StringWrapper.java
@@ -22,8 +22,11 @@
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Range;
+import com.google.common.collect.RangeSet;
 import com.google.common.collect.TreeRangeMap;
+import com.google.common.collect.TreeRangeSet;
 import com.palantir.javaformat.Newlines;
+import com.palantir.javaformat.Utils;
 import com.sun.source.tree.BinaryTree;
 import com.sun.source.tree.LiteralTree;
 import com.sun.source.tree.MemberSelectTree;
@@ -493,6 +496,42 @@ public static boolean needWrapping(int columnLimit, String input) {
         return false;
     }
 
+    /** Returns true if any lines in the given Java source exceed the column limit. */
+    public static boolean linesNeedWrapping(int columnLimit, String input, RangeSet<Integer> initialRangesToChange) {
+        // TODO(cushon): consider adding Newlines.lineIterable?
+        RangeSet<Integer> linesToChange = TreeRangeSet.create();
+        Iterator<String> it = Newlines.lineIterator(input);
+        int i = 0;
+        boolean insideTextBlock = false;
+        while (it.hasNext()) {
+            String line = it.next();
+            if (line.length() > columnLimit) {
+                linesToChange.add(Range.closedOpen(i, i + 1));
+            }
+            if (!insideTextBlock && line.contains(TEXT_BLOCK_DELIMITER)) {
+                insideTextBlock = true;
+                linesToChange.add(Range.closedOpen(i, i + 1));
+            } else if (insideTextBlock && line.contains(TEXT_BLOCK_DELIMITER)) {
+                insideTextBlock = false;
+                linesToChange.add(Range.closedOpen(i, i + 1));
+            } else if (insideTextBlock) {
+                linesToChange.add(Range.closedOpen(i, i + 1));
+            }
+            ++i;
+        }
+        RangeSet<Integer> charRangeToCheck = Utils.lineRangesToCharRanges(input, linesToChange);
+        return hasOverlap(initialRangesToChange, charRangeToCheck);
+    }
+
+    static boolean hasOverlap(RangeSet<Integer> a, RangeSet<Integer> b) {
+        for (Range<Integer> range : a.asRanges()) {
+            if (!b.subRangeSet(range).isEmpty()) {
+                return true;
+            }
+        }
+        return false;
+    }
+
     /** Parses the given Java source. */
     private static JCTree.JCCompilationUnit parse(String source, boolean allowStringFolding) throws FormatterException {
         Context context = new Context();
diff --git a/palantir-java-format/src/test/java/com/palantir/javaformat/java/StringWrapperTest.java b/palantir-java-format/src/test/java/com/palantir/javaformat/java/StringWrapperTest.java
@@ -17,6 +17,9 @@
 import static com.google.common.truth.Truth.assertThat;
 
 import com.google.common.base.Joiner;
+import com.google.common.collect.Range;
+import com.google.common.collect.RangeSet;
+import com.google.common.collect.TreeRangeSet;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.parallel.Execution;
 import org.junit.jupiter.api.parallel.ExecutionMode;
@@ -48,6 +51,54 @@ public void testAwkwardLineEndWrapping() throws Exception {
         assertThat(StringWrapper.wrap(100, input, Formatter.create())).isEqualTo(output);
     }
 
+    @Test
+    public void testLinesNeedWrapping() throws FormatterException {
+        String input =
+                """
+            class Value {
+                String a = \"""
+                hello
+                \""".codePoints();
+
+                String b = getMyValue();
+
+                String c = String.format("This is a String that contains more characters %s", getValue());
+            }
+            """;
+        String output =
+                """
+            class Value {
+              String a = \"""
+                  hello
+                  \""".codePoints();
+
+                String b = getMyValue();
+
+              String c =
+                  String.format("This is a String"
+                      + " that contains more"
+                      + " characters"
+                      + " %s", getValue());
+            }
+            """;
+
+        RangeSet<Integer> fullInput = TreeRangeSet.create();
+        fullInput.add(Range.closedOpen(0, input.length()));
+        assertThat(StringWrapper.linesNeedWrapping(40, input, fullInput)).isTrue();
+        assertThat(StringWrapper.wrap(40, input, Formatter.create())).isEqualTo(output);
+
+        RangeSet<Integer> noStringInput = TreeRangeSet.create();
+        int bAssignment = input.indexOf("String b");
+        int bEndLine = input.indexOf("\n", bAssignment);
+        noStringInput.add(Range.closed(bAssignment, bEndLine));
+        assertThat(StringWrapper.linesNeedWrapping(40, input, noStringInput)).isFalse();
+
+        RangeSet<Integer> onlyStringLiteralInput = TreeRangeSet.create();
+        onlyStringLiteralInput.add(Range.closedOpen(bEndLine + 1, input.length()));
+        assertThat(StringWrapper.linesNeedWrapping(40, input, onlyStringLiteralInput))
+                .isTrue();
+    }
+
     private static String lines(String... line) {
         return Joiner.on('\n').join(line) + '\n';
     }

Original file line number	Diff line number	Diff line change
`@@ -61,7 +61,8 @@ public ImmutableList<Replacement> getFormatReplacements(String input, Collection`
`61`	`61`	`}`
`62`	`62`	`return MAPPER.readValue(output.get(), new TypeReference<>() {});`
`63`	`63`	`} catch (IOException e) {`
`64`		`- throw new UncheckedIOException(String.format("Error running the native image command %s", output), e);`
	`64`	`+ throw new UncheckedIOException(`
	`65`	`+ String.format("Error running the native image command; received output: %s", output), e);`
`65`	`66`	`}`
`66`	`67`	`}`
`67`	`68`