Index: include/clang/Tooling/Core/Replacement.h =================================================================== --- include/clang/Tooling/Core/Replacement.h +++ include/clang/Tooling/Core/Replacement.h @@ -57,6 +57,18 @@ return RHS.Offset >= Offset && (RHS.Offset + RHS.Length) <= (Offset + Length); } + + /// \brief Whether this range is less-than \p RHS or not. + bool operator<(const Range &RHS) const { + if (Offset != RHS.getOffset()) + return Offset < RHS.getOffset(); + return Length < RHS.getLength(); + } + + /// \brief Whether this range equals to \p RHS or not. + bool operator==(const Range &RHS) const { + return Offset == RHS.getOffset() && Length == RHS.getLength(); + } /// @} private: @@ -222,11 +234,25 @@ std::string applyAllReplacements(StringRef Code, const Replacements &Replaces); /// \brief Calculates the ranges in a single file that are affected by the -/// Replacements. +/// Replacements. Overlapping ranges will be merged. /// /// \pre Replacements must be for the same file. +/// +/// \returns a non-overlapping and sorted ranges. std::vector calculateChangedRanges(const Replacements &Replaces); +/// \brief Calculates the new ranges after \p Replaces are applied. These +/// include both the original \p Ranges and the affected ranges of \p Replaces +/// in the new code. +/// +/// \pre Replacements must be for the same file. +/// +/// \return The new ranges after \p Replaces are applied. The new ranges will be +/// sorted and non-overlapping. +std::vector +calculateRangesAfterReplacements(const Replacements &Replaces, + const std::vector &Ranges); + /// \brief Groups a random set of replacements by file path. Replacements /// related to the same file entry are put into the same vector. std::map Index: lib/Tooling/Core/Replacement.cpp =================================================================== --- lib/Tooling/Core/Replacement.cpp +++ lib/Tooling/Core/Replacement.cpp @@ -278,6 +278,29 @@ return Result; } +// Merge and sort overlapping ranges in \p Ranges. +static std::vector mergeAndSortRanges(std::vector Ranges) { + if (Ranges.empty()) + return Ranges; + std::vector Result; + std::sort(Ranges.begin(), Ranges.end()); + auto I = Ranges.begin(); + unsigned CurBegin = I->getOffset(); + unsigned CurEnd = CurBegin + I->getLength(); + ++I; + for (auto E = Ranges.end(); I != E; ++I) { + if (CurEnd < I->getOffset()) { + Result.emplace_back(CurBegin, CurEnd - CurBegin); + CurBegin = I->getOffset(); + CurEnd = CurBegin + I->getLength(); + continue; + } + CurEnd = std::max(CurEnd, I->getOffset() + I->getLength()); + } + Result.emplace_back(CurBegin, CurEnd - CurBegin); + return Result; +} + std::vector calculateChangedRanges(const Replacements &Replaces) { std::vector ChangedRanges; int Shift = 0; @@ -287,7 +310,25 @@ Shift += Length - R.getLength(); ChangedRanges.push_back(Range(Offset, Length)); } - return ChangedRanges; + return mergeAndSortRanges(ChangedRanges); +} + +std::vector +calculateRangesAfterReplacements(const Replacements &Replaces, + const std::vector &Ranges) { + if (Ranges.empty()) + return calculateChangedRanges(Replaces); + + if (Replaces.empty()) + return Ranges; + + tooling::Replacements FakeReplaces; + for (const auto &R : Ranges) + FakeReplaces.insert(Replacement(Replaces.begin()->getFilePath(), + R.getOffset(), R.getLength(), + std::string(" ", R.getLength()))); + tooling::Replacements NewReplaces = mergeReplacements(FakeReplaces, Replaces); + return calculateChangedRanges(NewReplaces); } namespace { @@ -434,4 +475,3 @@ } // end namespace tooling } // end namespace clang - Index: unittests/Tooling/RefactoringTest.cpp =================================================================== --- unittests/Tooling/RefactoringTest.cpp +++ unittests/Tooling/RefactoringTest.cpp @@ -462,13 +462,96 @@ std::vector Ranges = calculateChangedRanges(Replaces); - EXPECT_EQ(3ul, Ranges.size()); + EXPECT_EQ(2ul, Ranges.size()); EXPECT_TRUE(Ranges[0].getOffset() == 0); EXPECT_TRUE(Ranges[0].getLength() == 0); EXPECT_TRUE(Ranges[1].getOffset() == 6); - EXPECT_TRUE(Ranges[1].getLength() == 6); - EXPECT_TRUE(Ranges[2].getOffset() == 12); - EXPECT_TRUE(Ranges[2].getLength() == 16); + EXPECT_TRUE(Ranges[1].getLength() == 22); +} + +TEST(Range, RangesAfterReplacements) { + std::vector Ranges = {Range(5, 2), Range(10, 5)}; + Replacements Replaces = {Replacement("foo", 0, 2, "1234")}; + std::vector Expected = {Range(0, 4), Range(7, 2), Range(12, 5)}; + EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges)); +} + +TEST(Range, RangesBeforeReplacements) { + std::vector Ranges = {Range(5, 2), Range(10, 5)}; + Replacements Replaces = {Replacement("foo", 20, 2, "1234")}; + std::vector Expected = {Range(5, 2), Range(10, 5), Range(20, 4)}; + EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges)); +} + +TEST(Range, NotAffectedByReplacements) { + std::vector Ranges = {Range(0, 2), Range(5, 2), Range(10, 5)}; + Replacements Replaces = {Replacement("foo", 3, 2, "12"), + Replacement("foo", 12, 2, "12"), + Replacement("foo", 20, 5, "")}; + std::vector Expected = {Range(0, 2), Range(3, 4), Range(10, 5), + Range(20, 0)}; + EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges)); +} + +TEST(Range, RangesWithNonOverlappingReplacements) { + std::vector Ranges = {Range(0, 2), Range(5, 2), Range(10, 5)}; + Replacements Replaces = {Replacement("foo", 3, 1, ""), + Replacement("foo", 6, 1, "123"), + Replacement("foo", 20, 2, "12345")}; + std::vector Expected = {Range(0, 2), Range(3, 0), Range(4, 4), + Range(11, 5), Range(21, 5)}; + EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges)); +} + +TEST(Range, RangesWithOverlappingReplacements) { + std::vector Ranges = {Range(0, 2), Range(5, 2), Range(15, 5), + Range(30, 5)}; + Replacements Replaces = { + Replacement("foo", 1, 3, ""), Replacement("foo", 6, 1, "123"), + Replacement("foo", 13, 3, "1"), Replacement("foo", 25, 15, "")}; + std::vector Expected = {Range(0, 1), Range(2, 4), Range(12, 5), + Range(22, 0)}; + EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges)); +} + +TEST(Range, MergeIntoOneRange) { + std::vector Ranges = {Range(0, 2), Range(5, 2), Range(15, 5)}; + Replacements Replaces = {Replacement("foo", 1, 15, "1234567890")}; + std::vector Expected = {Range(0, 15)}; + EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges)); +} + +TEST(Range, ReplacementsStartingAtRangeOffsets) { + std::vector Ranges = {Range(0, 2), Range(5, 5), Range(15, 5)}; + Replacements Replaces = { + Replacement("foo", 0, 2, "12"), Replacement("foo", 5, 1, "123"), + Replacement("foo", 7, 4, "12345"), Replacement("foo", 15, 10, "12")}; + std::vector Expected = {Range(0, 2), Range(5, 9), Range(18, 2)}; + EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges)); +} + +TEST(Range, ReplacementsEndingAtRangeEnds) { + std::vector Ranges = {Range(0, 2), Range(5, 2), Range(15, 5)}; + Replacements Replaces = {Replacement("foo", 6, 1, "123"), + Replacement("foo", 17, 3, "12")}; + std::vector Expected = {Range(0, 2), Range(5, 4), Range(17, 4)}; + EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges)); +} + +TEST(Range, AjacentReplacements) { + std::vector Ranges = {Range(0, 0), Range(15, 5)}; + Replacements Replaces = {Replacement("foo", 1, 2, "123"), + Replacement("foo", 12, 3, "1234")}; + std::vector Expected = {Range(0, 0), Range(1, 3), Range(13, 9)}; + EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges)); +} + +TEST(Range, MergeRangesAfterReplacements) { + std::vector Ranges = {Range(8, 0), Range(5, 2), Range(9, 0), Range(0, 1)}; + Replacements Replaces = {Replacement("foo", 1, 3, ""), + Replacement("foo", 7, 0, "12"), Replacement("foo", 9, 2, "")}; + std::vector Expected = {Range(0, 1), Range(2, 4), Range(7, 0), Range(8, 0)}; + EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges)); } TEST(DeduplicateTest, removesDuplicates) {