From 9485aec00f9b8c9bd6713bef8a41979ed39ef28c Mon Sep 17 00:00:00 2001 From: Alex Abashev Date: Sat, 14 Nov 2026 23:49:05 +0300 Subject: [PATCH 1/2] Reflow only the strings in the code that formatting the ranges rewrites --output-replacements, which IntelliJ IDEA and formatDiff run, and now the in-process service too, reflowed the whole file once a line in the ranges needed it, and long strings on lines nobody touched changed with it (#219). StringWrapper.wrap takes the ranges and reflows only the literals and text blocks that overlap them. Its passes format and replace text, so the ranges move along with each of them, growing to take in what a replacement rewrites. The ranges it gets are those of the code that formatting the given ranges rewrote, and they also decide whether to reflow at all; that check used to hold the ranges of the input against the lines of the formatted text. Without ranges nothing changes: the whole file is reflowed as before. --- .../javaformat/java/FormatterService.java | 3 + .../palantir/javaformat/java/Formatter.java | 14 +- .../javaformat/java/StringWrapper.java | 124 +++++++++++++++--- .../javaformat/java/StringWrapperTest.java | 55 ++++++++ 4 files changed, 174 insertions(+), 22 deletions(-) diff --git a/open-java-format-spi/src/main/java/com/palantir/javaformat/java/FormatterService.java b/open-java-format-spi/src/main/java/com/palantir/javaformat/java/FormatterService.java index 292549467..a314ac57a 100644 --- a/open-java-format-spi/src/main/java/com/palantir/javaformat/java/FormatterService.java +++ b/open-java-format-spi/src/main/java/com/palantir/javaformat/java/FormatterService.java @@ -28,6 +28,9 @@ public interface FormatterService { /** * Emit a list of {@link Replacement}s to convert from input to formatted output. * + *

The ranges are formatted, and the long strings in the code that formatting them rewrites are reflowed; the + * imports, and the strings elsewhere, stay as they are. + * * @param input the input compilation unit * @param ranges the character ranges to reformat * @return a list of {@link Replacement}s, sorted from low index to high index, without overlaps diff --git a/open-java-format/src/main/java/com/palantir/javaformat/java/Formatter.java b/open-java-format/src/main/java/com/palantir/javaformat/java/Formatter.java index 215094cd8..d26d8d621 100644 --- a/open-java-format/src/main/java/com/palantir/javaformat/java/Formatter.java +++ b/open-java-format/src/main/java/com/palantir/javaformat/java/Formatter.java @@ -366,19 +366,21 @@ public List getFormatReplacements(String input, Collection getFormatAndReflowReplacements(String input, RangeSet characterRanges) throws FormatterException { List replacements = getFormatReplacements(input, characterRanges.asRanges()); String formatted = Utils.applyReplacements(input, replacements); - // avoid trying to wrap the input unless the lines needing wrapping are part of the "characterRanges" - if (!StringWrapper.linesNeedWrapping(options.maxLineLength(), formatted, characterRanges)) { + RangeSet formattedRanges = StringWrapper.moveRanges(characterRanges, replacements); + // avoid trying to wrap the input unless the lines needing wrapping are part of the ranges + if (!StringWrapper.linesNeedWrapping(options.maxLineLength(), formatted, formattedRanges)) { return replacements; } - String wrapped = StringWrapper.wrap(options.maxLineLength(), formatted, this); + String wrapped = StringWrapper.wrap(options.maxLineLength(), formatted, formattedRanges, this); // if no wrapping change happened, return the initial replacements if (wrapped.equals(formatted)) { return replacements; diff --git a/open-java-format/src/main/java/com/palantir/javaformat/java/StringWrapper.java b/open-java-format/src/main/java/com/palantir/javaformat/java/StringWrapper.java index c6a54eb3a..110a7067f 100644 --- a/open-java-format/src/main/java/com/palantir/javaformat/java/StringWrapper.java +++ b/open-java-format/src/main/java/com/palantir/javaformat/java/StringWrapper.java @@ -19,6 +19,7 @@ import com.google.common.base.CharMatcher; import com.google.common.base.Verify; +import com.google.common.collect.DiscreteDomain; import com.google.common.collect.Range; import com.google.common.collect.RangeSet; import com.google.common.collect.TreeRangeMap; @@ -41,6 +42,7 @@ import com.sun.tools.javac.util.Position.LineMap; import java.util.ArrayDeque; import java.util.ArrayList; +import java.util.Collection; import java.util.Collections; import java.util.Comparator; import java.util.Deque; @@ -72,16 +74,30 @@ public final class StringWrapper { * adjacent string literals that share a line. */ static String wrap(final int columnLimit, String input, Formatter formatter) throws FormatterException { - String result = wrapOnce(columnLimit, input, formatter); - for (int round = 1; round < MAX_ROUNDS && !result.equals(input); round++) { + return wrap(columnLimit, new Source(input, null), formatter).text(); + } + + /** + * Reflows, as {@link #wrap(int, String, Formatter)} does, only the string literals and text blocks that overlap + * the given character ranges: when part of a file is formatted, the long strings in the rest of it stay as they + * are. + */ + static String wrap(final int columnLimit, String input, RangeSet characterRanges, Formatter formatter) + throws FormatterException { + return wrap(columnLimit, new Source(input, characterRanges), formatter).text(); + } + + private static Source wrap(final int columnLimit, Source input, Formatter formatter) throws FormatterException { + Source result = wrapOnce(columnLimit, input, formatter); + for (int round = 1; round < MAX_ROUNDS && !result.text().equals(input.text()); round++) { input = result; result = wrapOnce(columnLimit, input, formatter); } return result; } - private static String wrapOnce(final int columnLimit, String input, Formatter formatter) throws FormatterException { - if (!needWrapping(columnLimit, input)) { + private static Source wrapOnce(final int columnLimit, Source input, Formatter formatter) throws FormatterException { + if (!needWrapping(columnLimit, input.text())) { // fast path return input; } @@ -89,36 +105,36 @@ private static String wrapOnce(final int columnLimit, String input, Formatter fo // The pieces continue the way the formatter continues a chain of +: four columns times the multiplier of its // style, eight in OJF. var continuationIndent = 4 * formatter.options().indentationMultiplier(); - TreeRangeMap replacements = getReflowReplacements(columnLimit, continuationIndent, input); + TreeRangeMap replacements = input.reflowReplacements(columnLimit, continuationIndent); if (replacements.asMapOfRanges().isEmpty()) { // needWrapping is an over-approximation, so there may be nothing to do after all. return input; } - String firstPass = - formatter.formatSource(input, replacements.asMapOfRanges().keySet()); + Source firstPass = input.format(formatter, replacements.asMapOfRanges().keySet()); - if (!firstPass.equals(input)) { + if (!firstPass.text().equals(input.text())) { // If formatting the replacement ranges resulted in a change, recalculate the replacements on // the updated input. input = firstPass; - replacements = getReflowReplacements(columnLimit, continuationIndent, input); + replacements = input.reflowReplacements(columnLimit, continuationIndent); } - String result = applyReplacements(input, replacements); + Source result = input.apply(replacements); // Format again, because broken strings might now fit on the first line in case of assignments - String secondPass = formatter.formatSource(result, rangesAfterAppliedReplacements(replacements)); + Source secondPass = result.format(formatter, rangesAfterAppliedReplacements(replacements)); - if (!secondPass.equals(result)) { - replacements = getReflowReplacements(columnLimit, continuationIndent, secondPass); - result = applyReplacements(secondPass, replacements); + if (!secondPass.text().equals(result.text())) { + replacements = secondPass.reflowReplacements(columnLimit, continuationIndent); + result = secondPass.apply(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(); + String expected = + parse(input.text(), /* allowStringFolding= */ true).toString(); + String actual = parse(result.text(), /* allowStringFolding= */ true).toString(); if (!expected.equals(actual)) { throw new FormatterException(String.format( "Something has gone terribly wrong. Please file a bug: " @@ -131,6 +147,82 @@ private static String wrapOnce(final int columnLimit, String input, Formatter fo return result; } + /** + * The source between two passes of {@link #wrapOnce}, with the character ranges of it that the passes may change: + * the ranges being formatted, moved along with every change, or {@code null} when the whole file is. + */ + private record Source(String text, @Nullable RangeSet ranges) { + + /** The replacements of {@link #getReflowReplacements}, less those for literals outside the ranges. */ + TreeRangeMap reflowReplacements(int columnLimit, int continuationIndent) + throws FormatterException { + TreeRangeMap replacements = getReflowReplacements(columnLimit, continuationIndent, text); + RangeSet within = ranges; + if (within == null) { + return replacements; + } + TreeRangeMap inRanges = TreeRangeMap.create(); + replacements.asMapOfRanges().forEach((literal, replacement) -> { + if (within.intersects(literal)) { + inRanges.put(literal, replacement); + } + }); + return inRanges; + } + + /** Formats the given ranges, as {@link Formatter#formatSource(String, Collection)} does. */ + Source format(Formatter formatter, Collection> rangesToFormat) throws FormatterException { + List replacements = formatter.getFormatReplacements(text, rangesToFormat); + return new Source(Utils.applyReplacements(text, replacements), moved(replacements)); + } + + Source apply(TreeRangeMap replacements) { + List applied = replacements.asMapOfRanges().entrySet().stream() + .map(entry -> Replacement.create( + entry.getKey().lowerEndpoint(), entry.getKey().upperEndpoint(), entry.getValue())) + .toList(); + return new Source(applyReplacements(text, replacements), moved(applied)); + } + + private @Nullable RangeSet moved(List replacements) { + return ranges == null ? null : moveRanges(ranges, replacements); + } + } + + /** + * Where the given character ranges are once the replacements, sorted and without overlaps, have been applied. A + * range grows to take in all of a replacement that overlaps it, or that inserts text at its start. + */ + static RangeSet moveRanges(RangeSet ranges, List replacements) { + RangeSet moved = TreeRangeSet.create(); + for (Range range : ranges.asRanges()) { + Range canonical = range.canonical(DiscreteDomain.integers()); + moved.add(Range.closedOpen( + movePosition(canonical.lowerEndpoint(), replacements, /* start= */ true), + movePosition(canonical.upperEndpoint(), replacements, /* start= */ false))); + } + return moved; + } + + private static int movePosition(int position, List replacements, boolean start) { + int shift = 0; + for (Replacement replacement : replacements) { + int lower = replacement.getReplaceRange().lowerEndpoint(); + int upper = replacement.getReplaceRange().upperEndpoint(); + int length = replacement.getReplacementString().length(); + if (upper < position || (upper == position && lower < position)) { + // Before the position. + shift += length - (upper - lower); + } else if (lower < position) { + // Around the position, which moves to the replacement's start or end. + return lower + shift + (start ? 0 : length); + } else { + break; + } + } + return position + shift; + } + private static Set> rangesAfterAppliedReplacements(TreeRangeMap replacements) { var outputRanges = new LinkedHashSet>(); int offset = 0; diff --git a/open-java-format/src/test/java/com/palantir/javaformat/java/StringWrapperTest.java b/open-java-format/src/test/java/com/palantir/javaformat/java/StringWrapperTest.java index 1379bd871..34e466178 100644 --- a/open-java-format/src/test/java/com/palantir/javaformat/java/StringWrapperTest.java +++ b/open-java-format/src/test/java/com/palantir/javaformat/java/StringWrapperTest.java @@ -19,6 +19,9 @@ import com.google.common.base.Joiner; import com.google.common.collect.Iterables; +import com.google.common.collect.Range; +import com.google.common.collect.RangeSet; +import com.google.common.collect.TreeRangeSet; import com.sun.source.tree.BinaryTree; import com.sun.source.tree.ClassTree; import com.sun.source.tree.CompilationUnitTree; @@ -29,6 +32,7 @@ import java.io.IOException; import java.net.URI; import java.util.List; +import java.util.Set; import javax.tools.JavaFileObject; import javax.tools.SimpleJavaFileObject; import javax.tools.ToolProvider; @@ -94,6 +98,57 @@ void wrappingKeepsTheValueOfAStringWithEscapes() throws Exception { assertThat(stringValue(output)).isEqualTo(stringValue(input)); } + @Test + void wrapsOnlyTheStringsInTheRanges() throws Exception { + // As when one line of the file is formatted: the long string on the other line stays as it is. + String input = """ + class T { + String outside = "one long incredibly unbroken sentence moving from topic to topic so that no one had a chance"; + String inside = "one long incredibly unbroken sentence moving from topic to topic so that no one had a chance"; + } + """; + String output = """ + class T { + String outside = "one long incredibly unbroken sentence moving from topic to topic so that no one had a chance"; + String inside = + "one long incredibly unbroken sentence moving from topic to topic so that no one had a" + + " chance"; + } + """; + int inside = input.indexOf(" String inside"); + RangeSet insideLine = + TreeRangeSet.create(List.of(Range.closedOpen(inside, input.indexOf('\n', inside)))); + RangeSet wholeFile = TreeRangeSet.create(List.of(Range.closedOpen(0, input.length()))); + + assertThat(StringWrapper.wrap(100, input, insideLine, Formatter.create())) + .isEqualTo(output); + assertThat(StringWrapper.wrap(100, input, wholeFile, Formatter.create())) + .isEqualTo(StringWrapper.wrap(100, input, Formatter.create())); + } + + @Test + void movesRangesAlongWithTheReplacements() { + // Characters 4 to 8 become two, and two are inserted at 12. + List replacements = List.of(Replacement.create(4, 8, "ab"), Replacement.create(12, 12, "cd")); + + // Before the replacements, and after the first one. + assertThat(moved(Range.closedOpen(0, 2), replacements)).containsExactly(Range.closedOpen(0, 2)); + assertThat(moved(Range.closedOpen(9, 11), replacements)).containsExactly(Range.closedOpen(7, 9)); + // Over the start or the end of a replacement: the range takes in all of it. + assertThat(moved(Range.closedOpen(2, 5), replacements)).containsExactly(Range.closedOpen(2, 6)); + assertThat(moved(Range.closedOpen(6, 10), replacements)).containsExactly(Range.closedOpen(4, 8)); + // Text inserted at the start of a range goes in, at its end it does not. + assertThat(moved(Range.closedOpen(12, 14), replacements)).containsExactly(Range.closedOpen(10, 14)); + assertThat(moved(Range.closedOpen(10, 12), replacements)).containsExactly(Range.closedOpen(8, 10)); + // A closed range moves as the half-open one with the same characters. + assertThat(moved(Range.closed(9, 10), replacements)).containsExactly(Range.closedOpen(7, 9)); + } + + private static Set> moved(Range range, List replacements) { + return StringWrapper.moveRanges(TreeRangeSet.create(List.of(range)), replacements) + .asRanges(); + } + /** 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) { From c799977bfa1fccbc90b4e689e8799cf80d188b3a Mon Sep 17 00:00:00 2001 From: Alex Abashev Date: Tue, 17 Nov 2026 21:45:02 +0300 Subject: [PATCH 2/2] Leave long strings outside the changed lines in the service tests The tests of FormatterServicesTest and FormatDiffTest that reflow a long string on a changed line, with each of the in-process, bootstrapping and native formatters, get another long string, on a line that is not changed: it stays as it is. --- .../java/com/palantir/javaformat/gradle/FormatDiffTest.java | 5 +++++ .../palantir/javaformat/bootstrap/FormatterServicesTest.java | 4 ++++ 2 files changed, 9 insertions(+) diff --git a/gradle-open-java-format/src/test/java/com/palantir/javaformat/gradle/FormatDiffTest.java b/gradle-open-java-format/src/test/java/com/palantir/javaformat/gradle/FormatDiffTest.java index ba6613aa2..e250a3e60 100644 --- a/gradle-open-java-format/src/test/java/com/palantir/javaformat/gradle/FormatDiffTest.java +++ b/gradle-open-java-format/src/test/java/com/palantir/javaformat/gradle/FormatDiffTest.java @@ -96,6 +96,7 @@ void reflows_the_long_string_of_a_changed_line(FormatterService formatterService Path longString = repo.resolve("LongString.java"); Files.writeString(longString, """ class LongString { + String outside = "Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat sed."; } """); runCommandInRepo("git", "add", "."); @@ -103,6 +104,8 @@ class LongString { Files.writeString(longString, """ class LongString { + String outside = "Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat sed."; + String changed = "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna."; } """); @@ -111,6 +114,8 @@ class LongString { assertThat(longString).hasContent(""" class LongString { + String outside = "Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat sed."; + String changed = "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et" + " dolore magna."; diff --git a/open-java-format-jdk-bootstrap/src/test/java/com/palantir/javaformat/bootstrap/FormatterServicesTest.java b/open-java-format-jdk-bootstrap/src/test/java/com/palantir/javaformat/bootstrap/FormatterServicesTest.java index 186c375c4..a59aa4299 100644 --- a/open-java-format-jdk-bootstrap/src/test/java/com/palantir/javaformat/bootstrap/FormatterServicesTest.java +++ b/open-java-format-jdk-bootstrap/src/test/java/com/palantir/javaformat/bootstrap/FormatterServicesTest.java @@ -102,11 +102,15 @@ public void main( String aaaa ) { void reflows_the_long_string_of_the_range(FormatterService formatterService) throws FormatterException { String input = """ class S { + String outside = "Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat sed."; + String changed = "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna."; } """; String expectedOutput = """ class S { + String outside = "Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat sed."; + String changed = "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et" + " dolore magna.";