diff --git a/core/src/main/java/com/google/googlejavaformat/java/Cleanups.java b/core/src/main/java/com/google/googlejavaformat/java/Cleanups.java index 672ef61b1..baaa45d3e 100644 --- a/core/src/main/java/com/google/googlejavaformat/java/Cleanups.java +++ b/core/src/main/java/com/google/googlejavaformat/java/Cleanups.java @@ -14,7 +14,6 @@ package com.google.googlejavaformat.java; -import static com.google.common.base.Preconditions.checkArgument; import static java.lang.Math.max; import static java.lang.Math.min; @@ -50,57 +49,6 @@ record Result( Collection> characterRanges, @Nullable JCCompilationUnit unit) {} - /// One replacement: `[inStart, inEnd)` in the old contents became `[outStart, outEnd)`. - private record Span(int inStart, int inEnd, int outStart, int outEnd) {} - - /// The result of applying sorted, non-overlapping replacements to some text. - private record Edit(String contents, ImmutableList spans) { - - /// Applies sorted, non-overlapping replacements to `contents`. - static Edit apply(String contents, List replacements) { - StringBuilder sb = new StringBuilder(contents.length()); - ImmutableList.Builder spans = - ImmutableList.builderWithExpectedSize(replacements.size()); - int cursor = 0; - for (Replacement replacement : replacements) { - Range range = replacement.replaceRange(); - int inStart = range.lowerEndpoint(); - int inEnd = range.upperEndpoint(); - checkArgument( - inStart >= cursor, - "Replacements must be sorted and non-overlapping, but %s overlaps previous end %s", - range, - cursor); - sb.append(contents, cursor, inStart); - int outStart = sb.length(); - sb.append(replacement.replacementString()); - int outEnd = sb.length(); - spans.add(new Span(inStart, inEnd, outStart, outEnd)); - cursor = inEnd; - } - sb.append(contents, cursor, contents.length()); - return new Edit(sb.toString(), spans.build()); - } - - /// Maps an offset in the old contents to the corresponding offset in the new contents. - /// - /// Offsets before a span are unchanged relative to the previous span; offsets inside a span are - /// clamped to its replacement text; offsets after all spans are shifted by the final span. - int map(int offset) { - Span prev = null; - for (Span span : spans) { - if (offset < span.inStart()) { - return prev == null ? offset : prev.outEnd() + (offset - prev.inEnd()); - } - if (offset <= span.inEnd()) { - return span.outStart() + min(offset - span.inStart(), span.outEnd() - span.outStart()); - } - prev = span; - } - return prev == null ? offset : prev.outEnd() + (offset - prev.inEnd()); - } - } - private record Parsed(Context context, JCCompilationUnit unit) {} /// Returns the enabled passes for formatting or fixing imports. @@ -207,15 +155,8 @@ private void applyReplacements(List replacements) { return; } Edit edit = Edit.apply(contents, replacements); - RangeSet newRanges = TreeRangeSet.create(); - for (Range range : ranges.asRanges()) { - int mappedStart = edit.map(range.lowerEndpoint()); - int mappedEnd = edit.map(range.upperEndpoint()); - if (mappedStart < mappedEnd) { - newRanges.add(Range.closedOpen(mappedStart, mappedEnd)); - } - } - for (Span span : edit.spans()) { + RangeSet newRanges = TreeRangeSet.create(edit.mapRanges(ranges.asRanges())); + for (Edit.Span span : edit.spans()) { Range r = reformatRange(span, edit.contents()); if (!r.isEmpty()) { newRanges.add(r); @@ -228,7 +169,7 @@ private void applyReplacements(List replacements) { } /// Returns the range to reformat for the given span. - private static Range reformatRange(Span span, String contents) { + private static Range reformatRange(Edit.Span span, String contents) { if (span.outStart() == span.outEnd()) { return deletionReformatRange(contents, span.outStart()); } diff --git a/core/src/main/java/com/google/googlejavaformat/java/Edit.java b/core/src/main/java/com/google/googlejavaformat/java/Edit.java new file mode 100644 index 000000000..c7ac56c47 --- /dev/null +++ b/core/src/main/java/com/google/googlejavaformat/java/Edit.java @@ -0,0 +1,108 @@ +/* + * Copyright 2026 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except + * in compliance with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License + * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express + * or implied. See the License for the specific language governing permissions and limitations under + * the License. + */ + +package com.google.googlejavaformat.java; + +import static com.google.common.base.Preconditions.checkArgument; +import static com.google.common.base.Strings.commonPrefix; +import static com.google.common.base.Strings.commonSuffix; +import static java.lang.Math.min; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableRangeSet; +import com.google.common.collect.Range; +import com.google.common.collect.RangeSet; +import com.google.common.collect.TreeRangeSet; +import java.nio.CharBuffer; +import java.util.Collection; +import java.util.List; + +/// The result of applying sorted, non-overlapping replacements to some text, which can map offsets +/// in the old text to offsets in the new text. +record Edit(String contents, ImmutableList spans) { + + /// One replacement: `[inStart, inEnd)` in the old contents became `[outStart, outEnd)`. + record Span(int inStart, int inEnd, int outStart, int outEnd) {} + + /// Applies sorted, non-overlapping replacements to `contents`. + static Edit apply(String contents, List replacements) { + StringBuilder sb = new StringBuilder(contents.length()); + ImmutableList.Builder spans = ImmutableList.builderWithExpectedSize(replacements.size()); + int cursor = 0; + for (Replacement replacement : replacements) { + Range range = replacement.replaceRange(); + int inStart = range.lowerEndpoint(); + int inEnd = range.upperEndpoint(); + checkArgument( + inStart >= cursor, + "Replacements must be sorted and non-overlapping, but %s overlaps previous end %s", + range, + cursor); + sb.append(contents, cursor, inStart); + String replacementString = replacement.replacementString(); + int outStart = sb.length(); + sb.append(replacementString); + int outEnd = sb.length(); + // Trim any unchanged prefix and suffix so coarse replacements (such as reformatting an entire + // statement) don't treat unchanged tokens at the start or end of the replacement as part of + // the modified span. + int prefix = + commonPrefix(CharBuffer.wrap(contents, inStart, inEnd), replacementString).length(); + int suffix = + commonSuffix( + CharBuffer.wrap(contents, inStart + prefix, inEnd), + CharBuffer.wrap(replacementString, prefix, replacementString.length())) + .length(); + if (inStart + prefix < inEnd - suffix || outStart + prefix < outEnd - suffix) { + spans.add(new Span(inStart + prefix, inEnd - suffix, outStart + prefix, outEnd - suffix)); + } + cursor = inEnd; + } + sb.append(contents, cursor, contents.length()); + return new Edit(sb.toString(), spans.build()); + } + + /// Maps an offset in the old contents to the corresponding offset in the new contents. + /// + /// Offsets in unmodified text are shifted by the cumulative length change of preceding + /// replacements. Offsets inside a replaced range `[inStart, inEnd)` are shifted relative to + /// `inStart` and clamped to `outEnd` if the replacement is shorter than the original range. + int map(int offset) { + int shift = 0; + for (Span span : spans) { + if (offset < span.inStart()) { + return offset + shift; + } + if (offset < span.inEnd()) { + return min(offset + shift, span.outEnd()); + } + shift = span.outEnd() - span.inEnd(); + } + return offset + shift; + } + + /// Maps ranges in the old contents to the corresponding ranges in the new contents, dropping + /// ranges that become empty. + ImmutableRangeSet mapRanges(Collection> ranges) { + RangeSet result = TreeRangeSet.create(); + for (Range range : ranges) { + int start = map(range.lowerEndpoint()); + int end = map(range.upperEndpoint()); + if (start < end) { + result.add(Range.closedOpen(start, end)); + } + } + return ImmutableRangeSet.copyOf(result); + } +} diff --git a/core/src/main/java/com/google/googlejavaformat/java/Formatter.java b/core/src/main/java/com/google/googlejavaformat/java/Formatter.java index 4cb95bfd0..2b763c1fa 100644 --- a/core/src/main/java/com/google/googlejavaformat/java/Formatter.java +++ b/core/src/main/java/com/google/googlejavaformat/java/Formatter.java @@ -189,15 +189,20 @@ String formatSource( Cleanups.enabledPasses( options.cleanup(), removeUnusedImports, options.reorderModifiers(), sortImports); Cleanups.Result cleaned = Cleanups.apply(input, characterRanges, options.style(), passes); - String formatted = - JavaOutput.applyReplacements( + Edit formatted = + Edit.apply( cleaned.contents(), getFormatReplacements( cleaned.contents(), cleaned.characterRanges(), options.cleanup(), cleaned.unit())); if (reflowLongStrings) { - formatted = StringWrapper.wrap(options.maxLineLength(), formatted, this); + // Only reflow long strings in the requested ranges, mapped onto the formatted output. + return StringWrapper.wrap( + options.maxLineLength(), + formatted.contents(), + this, + formatted.mapRanges(cleaned.characterRanges())); } - return formatted; + return formatted.contents(); } /// Formats an input string (a Java compilation unit) and fixes imports. diff --git a/core/src/main/java/com/google/googlejavaformat/java/StringWrapper.java b/core/src/main/java/com/google/googlejavaformat/java/StringWrapper.java index 8b7393846..c87ca449b 100644 --- a/core/src/main/java/com/google/googlejavaformat/java/StringWrapper.java +++ b/core/src/main/java/com/google/googlejavaformat/java/StringWrapper.java @@ -22,7 +22,9 @@ import com.google.common.base.CharMatcher; import com.google.common.base.Verify; import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableRangeSet; import com.google.common.collect.Range; +import com.google.common.collect.RangeSet; import com.google.common.collect.TreeRangeMap; import com.google.googlejavaformat.Newlines; import com.sun.source.tree.BinaryTree; @@ -58,20 +60,36 @@ public static String wrap(String input, Formatter formatter) throws FormatterExc /// Reflows string literals in the given Java source code that extend past the given column limit. static String wrap(final int columnLimit, String input, Formatter formatter) throws FormatterException { + return wrap( + columnLimit, input, formatter, ImmutableRangeSet.of(Range.closedOpen(0, input.length()))); + } + + /// Reflows string literals in the given character ranges of the given Java source code that + /// extend past the given column limit. + static String wrap( + final int columnLimit, String input, Formatter formatter, RangeSet characterRanges) + throws FormatterException { JavaFormatterOptions options = formatter.options(); if (!needWrapping(columnLimit, input, options)) { // fast path return input; } - TreeRangeMap replacements = getReflowReplacements(columnLimit, input, options); - String firstPass = formatter.formatSource(input, replacements.asMapOfRanges().keySet()); + TreeRangeMap replacements = + getReflowReplacements(columnLimit, input, options, characterRanges); + if (replacements.asMapOfRanges().isEmpty()) { + return input; + } + Edit firstPass = + Edit.apply( + input, formatter.getFormatReplacements(input, replacements.asMapOfRanges().keySet())); - if (!firstPass.equals(input)) { + if (!firstPass.contents().equals(input)) { // If formatting the replacement ranges resulted in a change, recalculate the replacements on // the updated input. - input = firstPass; - replacements = getReflowReplacements(columnLimit, input, options); + input = firstPass.contents(); + characterRanges = firstPass.mapRanges(characterRanges.asRanges()); + replacements = getReflowReplacements(columnLimit, input, options, characterRanges); } String result = applyReplacements(input, replacements); @@ -111,8 +129,12 @@ private static FormatterException somethingHasGoneTerriblyWrong( } private static TreeRangeMap getReflowReplacements( - int columnLimit, final String input, JavaFormatterOptions options) throws FormatterException { - return new Reflower(columnLimit, input, options).getReflowReplacements(); + int columnLimit, + final String input, + JavaFormatterOptions options, + RangeSet characterRanges) + throws FormatterException { + return new Reflower(columnLimit, input, options, characterRanges).getReflowReplacements(); } private static class Reflower { @@ -120,15 +142,21 @@ private static class Reflower { private final String input; private final int columnLimit; private final JavaFormatterOptions options; + private final RangeSet characterRanges; private final String separator; private final JCTree.JCCompilationUnit unit; private final Position.LineMap lineMap; - Reflower(int columnLimit, String input, JavaFormatterOptions options) + Reflower( + int columnLimit, + String input, + JavaFormatterOptions options, + RangeSet characterRanges) throws FormatterException { this.columnLimit = columnLimit; this.input = input; this.options = options; + this.characterRanges = characterRanges; this.separator = Newlines.guessLineSeparator(input); this.unit = parse(input, /* allowStringFolding= */ false); this.lineMap = unit.getLineMap(); @@ -170,6 +198,10 @@ public Void visitLiteral(LiteralTree literalTree, Void aVoid) { return null; } int endPosition = getEndPosition(literalTree, unit); + if (!characterRanges.intersects( + Range.closedOpen(getStartPosition(literalTree), endPosition))) { + return null; + } int lineEnd = endPosition; while (Newlines.hasNewlineAt(input, lineEnd) == -1) { lineEnd++; diff --git a/core/src/test/java/com/google/googlejavaformat/java/EditTest.java b/core/src/test/java/com/google/googlejavaformat/java/EditTest.java new file mode 100644 index 000000000..4d5803956 --- /dev/null +++ b/core/src/test/java/com/google/googlejavaformat/java/EditTest.java @@ -0,0 +1,201 @@ +/* + * Copyright 2026 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except + * in compliance with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License + * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express + * or implied. See the License for the specific language governing permissions and limitations under + * the License. + */ + +package com.google.googlejavaformat.java; + +import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertThrows; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.Range; +import org.junit.Test; + +/// Tests for [Edit]. +public class EditTest { + + @Test + public void apply_emptyReplacements() { + Edit edit = Edit.apply("abcdef", ImmutableList.of()); + assertThat(edit.contents()).isEqualTo("abcdef"); + assertThat(edit.spans()).isEmpty(); + for (int i = 0; i <= 6; i++) { + assertThat(edit.map(i)).isEqualTo(i); + } + } + + @Test + public void apply_overlappingOrUnsorted_throws() { + ImmutableList overlapping = + ImmutableList.of(Replacement.create(1, 4, "x"), Replacement.create(3, 5, "y")); + assertThrows(IllegalArgumentException.class, () -> Edit.apply("abcdef", overlapping)); + ImmutableList unsorted = + ImmutableList.of(Replacement.create(3, 5, "y"), Replacement.create(1, 2, "x")); + assertThrows(IllegalArgumentException.class, () -> Edit.apply("abcdef", unsorted)); + } + + @Test + public void map_shorterReplacement() { + // Replace "2345" ([2, 6)) with "ab" ([2, 4)) in "01234567" -> "01ab67" + Edit edit = Edit.apply("01234567", ImmutableList.of(Replacement.create(2, 6, "ab"))); + assertThat(edit.contents()).isEqualTo("01ab67"); + // Unmodified prefix "01" + assertThat(edit.map(0)).isEqualTo(0); + assertThat(edit.map(1)).isEqualTo(1); + // Inside replaced range [2, 6): clamped to [2, 4] + assertThat(edit.map(2)).isEqualTo(2); + assertThat(edit.map(3)).isEqualTo(3); + assertThat(edit.map(4)).isEqualTo(4); + assertThat(edit.map(5)).isEqualTo(4); + // Unmodified suffix "67" (shifted by -2) + assertThat(edit.map(6)).isEqualTo(4); + assertThat(edit.map(7)).isEqualTo(5); + assertThat(edit.map(8)).isEqualTo(6); + } + + @Test + public void map_longerReplacement() { + // Replace "2" ([2, 3)) with "abcd" ([2, 6)) in "01234" -> "01abcd34" + Edit edit = Edit.apply("01234", ImmutableList.of(Replacement.create(2, 3, "abcd"))); + assertThat(edit.contents()).isEqualTo("01abcd34"); + assertThat(edit.map(0)).isEqualTo(0); + assertThat(edit.map(1)).isEqualTo(1); + assertThat(edit.map(2)).isEqualTo(2); + // End of replaced range (start of '3') maps to the end of "abcd" (offset 6) + assertThat(edit.map(3)).isEqualTo(6); + assertThat(edit.map(4)).isEqualTo(7); + assertThat(edit.map(5)).isEqualTo(8); + } + + @Test + public void map_replacementAtStart() { + // Replace "012" ([0, 3)) with "a" ([0, 1)) in "012345" -> "a345" + Edit edit = Edit.apply("012345", ImmutableList.of(Replacement.create(0, 3, "a"))); + assertThat(edit.contents()).isEqualTo("a345"); + assertThat(edit.spans()).containsExactly(new Edit.Span(0, 3, 0, 1)); + assertThat(edit.map(0)).isEqualTo(0); + assertThat(edit.map(1)).isEqualTo(1); + assertThat(edit.map(2)).isEqualTo(1); + assertThat(edit.map(3)).isEqualTo(1); + assertThat(edit.map(4)).isEqualTo(2); + assertThat(edit.map(6)).isEqualTo(4); + } + + @Test + public void map_replacementAtEnd() { + // Replace "45" ([4, 6)) with "abcd" ([4, 8)) in "012345" -> "0123abcd" + Edit edit = Edit.apply("012345", ImmutableList.of(Replacement.create(4, 6, "abcd"))); + assertThat(edit.contents()).isEqualTo("0123abcd"); + assertThat(edit.spans()).containsExactly(new Edit.Span(4, 6, 4, 8)); + assertThat(edit.map(3)).isEqualTo(3); + assertThat(edit.map(4)).isEqualTo(4); + assertThat(edit.map(5)).isEqualTo(5); + assertThat(edit.map(6)).isEqualTo(8); + } + + @Test + public void apply_insertionAndDeletionAtBoundaries() { + // Insert "x" at the start and delete the trailing "5" in "012345" -> "x01234" + Edit edit = + Edit.apply( + "012345", + ImmutableList.of(Replacement.create(0, 0, "x"), Replacement.create(5, 6, ""))); + assertThat(edit.contents()).isEqualTo("x01234"); + assertThat(edit.spans()) + .containsExactly(new Edit.Span(0, 0, 0, 1), new Edit.Span(5, 6, 6, 6)) + .inOrder(); + assertThat(edit.map(0)).isEqualTo(1); + assertThat(edit.map(5)).isEqualTo(6); + assertThat(edit.map(6)).isEqualTo(6); + } + + @Test + public void apply_unchangedReplacementHasNoSpan() { + // Replacing text with itself, including the whole input, doesn't record a span. + Edit edit = Edit.apply("012345", ImmutableList.of(Replacement.create(0, 6, "012345"))); + assertThat(edit.contents()).isEqualTo("012345"); + assertThat(edit.spans()).isEmpty(); + } + + @Test + public void map_deletionAndMultipleSpans() { + // In "0123456789": + // - delete [1, 3) ("12") -> [1, 1) + // - replace [5, 6) ("5") with "XYZ" -> [3, 6) + // - replace [6, 9) ("678") with "W" -> [6, 7) + // Result: "0" + "" + "34" + "XYZ" + "W" + "9" = "034XYZW9" + Edit edit = + Edit.apply( + "0123456789", + ImmutableList.of( + Replacement.create(1, 3, ""), + Replacement.create(5, 6, "XYZ"), + Replacement.create(6, 9, "W"))); + assertThat(edit.contents()).isEqualTo("034XYZW9"); + assertThat(edit.map(0)).isEqualTo(0); + // Deleted [1, 3) collapses to offset 1 + assertThat(edit.map(1)).isEqualTo(1); + assertThat(edit.map(2)).isEqualTo(1); + assertThat(edit.map(3)).isEqualTo(1); + // Between first and second replacement ("34" at [3, 5) -> [1, 3)) + assertThat(edit.map(4)).isEqualTo(2); + // Start of second replacement ("5" at [5, 6) -> "XYZ" at [3, 6)) + assertThat(edit.map(5)).isEqualTo(3); + // Boundary between adjacent second and third replacements ([6, 9) -> "W" at [6, 7)) + assertThat(edit.map(6)).isEqualTo(6); + assertThat(edit.map(7)).isEqualTo(7); + assertThat(edit.map(8)).isEqualTo(7); + assertThat(edit.map(9)).isEqualTo(7); + // Trailing "9" at [9, 10) -> [7, 8) + assertThat(edit.map(10)).isEqualTo(8); + } + + @Test + public void map_coarseReplacementTrimsCommonPrefixAndSuffix() { + // Replace the whole string "prefix suffix" with "prefix suffix"; offsets inside "suffix" + // should be shifted by -3 rather than clamped to the end of the replacement. + String input = "prefix suffix"; + String output = "prefix suffix"; + Edit edit = Edit.apply(input, ImmutableList.of(Replacement.create(0, input.length(), output))); + assertThat(edit.contents()).isEqualTo(output); + int inSuffixStart = input.indexOf("suffix"); + int outSuffixStart = output.indexOf("suffix"); + assertThat(edit.map(inSuffixStart)).isEqualTo(outSuffixStart); + assertThat(edit.map(input.length())).isEqualTo(output.length()); + } + + @Test + public void mapRanges() { + // In "0123456789": + // - delete [2, 5) ("234") + // - replace [7, 8) ("7") with "ABCD" + // Result: "01" + "56" + "ABCD" + "89" = "0156ABCD89" + Edit edit = + Edit.apply( + "0123456789", + ImmutableList.of(Replacement.create(2, 5, ""), Replacement.create(7, 8, "ABCD"))); + assertThat(edit.contents()).isEqualTo("0156ABCD89"); + assertThat( + edit.mapRanges( + ImmutableList.of( + Range.closedOpen(0, 1), // "0" -> [0, 1) + Range.closedOpen(2, 5), // deleted "234" -> empty, dropped + Range.closedOpen(3, 4), // inside deleted "234" -> empty, dropped + Range.closedOpen(5, 7), // "56" -> [2, 4) + Range.closedOpen(7, 8), // "7" -> "ABCD" at [4, 8) + Range.closedOpen(9, 10))) // "9" -> [9, 10) + .asRanges()) + .containsExactly(Range.closedOpen(0, 1), Range.closedOpen(2, 8), Range.closedOpen(9, 10)) + .inOrder(); + } +} diff --git a/core/src/test/java/com/google/googlejavaformat/java/MainTest.java b/core/src/test/java/com/google/googlejavaformat/java/MainTest.java index a728c2515..439286e6c 100644 --- a/core/src/test/java/com/google/googlejavaformat/java/MainTest.java +++ b/core/src/test/java/com/google/googlejavaformat/java/MainTest.java @@ -34,6 +34,7 @@ import java.nio.file.Path; import java.nio.file.Paths; import java.nio.file.attribute.PosixFilePermission; +import java.util.Arrays; import java.util.EnumSet; import java.util.Locale; import org.junit.Rule; @@ -603,6 +604,41 @@ class T { assertThat(out.toString()).isEqualTo(expected); } + // https://github.com/google/google-java-format/issues/1114 + @Test + public void reflowLongStrings_onlyInRequestedLines() throws Exception { + String input = + """ + class T { + String s = "one long incredibly unbroken sentence moving from topic to topic so that no one had a chance to interrupt"; + String t = "one long incredibly unbroken sentence moving from topic to topic so that no one had a chance to interrupt"; + } + """; + String expected = + """ + class T { + String s = "one long incredibly unbroken sentence moving from topic to topic so that no one had a chance to interrupt"; + String t = + "one long incredibly unbroken sentence moving from topic to topic so that no one had a chance" + + " to interrupt"; + } + """; + assertThat(formatStdin(input, "-lines", "3")).isEqualTo(expected); + // Nothing on the first line needs formatting, so nothing changes. + assertThat(formatStdin(input, "-lines", "1")).isEqualTo(input); + } + + private static String formatStdin(String input, String... args) throws Exception { + InputStream in = new ByteArrayInputStream(input.getBytes(UTF_8)); + StringWriter out = new StringWriter(); + StringWriter err = new StringWriter(); + Main main = new Main(new PrintWriter(out, true), new PrintWriter(err, true), in); + String[] argsWithStdin = Arrays.copyOf(args, args.length + 1); + argsWithStdin[args.length] = "-"; + assertWithMessage(err.toString()).that(main.format(argsWithStdin)).isEqualTo(0); + return out.toString(); + } + @Test public void noFormatJavadoc() throws Exception { String input = diff --git a/core/src/test/java/com/google/googlejavaformat/java/StringWrapperTest.java b/core/src/test/java/com/google/googlejavaformat/java/StringWrapperTest.java index 9a5875dec..7ef7b553d 100644 --- a/core/src/test/java/com/google/googlejavaformat/java/StringWrapperTest.java +++ b/core/src/test/java/com/google/googlejavaformat/java/StringWrapperTest.java @@ -17,6 +17,8 @@ import static com.google.common.truth.Truth.assertThat; import static org.junit.Assume.assumeTrue; +import com.google.common.collect.ImmutableRangeSet; +import com.google.common.collect.Range; import com.google.googlejavaformat.java.JavaFormatterOptions.Style; import java.util.Random; import org.junit.Test; @@ -188,4 +190,66 @@ public void escapesRandomized() throws Exception { String unused = StringWrapper.wrap(40, formatter.formatSource(input), formatter); } } + + // https://github.com/google/google-java-format/issues/1114 + @Test + public void wrap_onlyInCharacterRanges() throws Exception { + String input = + """ + class T { + String s = "one long incredibly unbroken sentence moving from topic to topic so that no one had a chance to interrupt"; + String t = "one long incredibly unbroken sentence moving from topic to topic so that no one had a chance to interrupt"; + } + """; + Formatter formatter = new Formatter(); + int tStart = input.indexOf("String t"); + int tEnd = input.indexOf(';', tStart); + assertThat( + StringWrapper.wrap( + 100, input, formatter, ImmutableRangeSet.of(Range.closedOpen(tStart, tEnd)))) + .isEqualTo( + """ + class T { + String s = "one long incredibly unbroken sentence moving from topic to topic so that no one had a chance to interrupt"; + String t = + "one long incredibly unbroken sentence moving from topic to topic so that no one had a chance" + + " to interrupt"; + } + """); + // A range that does not intersect any string literal returns the input unchanged. + assertThat( + StringWrapper.wrap(100, input, formatter, ImmutableRangeSet.of(Range.closedOpen(0, 9)))) + .isEqualTo(input); + } + + @Test + public void wrap_mapsCharacterRangesAfterFirstPass() throws Exception { + // The first pass formats the statement containing `t`, collapsing the extra spaces before the + // literal so its range in the formatted output is disjoint from its original range in `input`. + String input = + """ + class T { + String s = "one long incredibly unbroken sentence moving from topic to topic so that no one had a chance to interrupt"; + String t = %s"one long incredibly unbroken sentence moving from topic to topic so that no one had a chance to interrupt"; + } + """ + .formatted(" ".repeat(150)); + int tLiteralStart = input.lastIndexOf("\"one"); + int tLiteralEnd = input.indexOf(';', tLiteralStart); + assertThat( + StringWrapper.wrap( + 100, + input, + new Formatter(), + ImmutableRangeSet.of(Range.closedOpen(tLiteralStart, tLiteralEnd)))) + .isEqualTo( + """ + class T { + String s = "one long incredibly unbroken sentence moving from topic to topic so that no one had a chance to interrupt"; + String t = + "one long incredibly unbroken sentence moving from topic to topic so that no one had a chance" + + " to interrupt"; + } + """); + } }