r273290 - Added calculateRangesAfterReplaments() to calculate affacted ranges in the new code.
Eric Liu via cfe-commits
cfe-commits at lists.llvm.org
Tue Jun 21 10:56:32 PDT 2016
Author: ioeric
Date: Tue Jun 21 12:56:31 2016
New Revision: 273290
URL: http://llvm.org/viewvc/llvm-project?rev=273290&view=rev
Log:
Added calculateRangesAfterReplaments() to calculate affacted ranges in the new code.
Summary:
Added calculateRangesAfterReplaments() to calculate original ranges as well as
newly affacted ranges in the new code.
Reviewers: klimek, djasper
Subscribers: cfe-commits, klimek
Differential Revision: http://reviews.llvm.org/D21547
Modified:
cfe/trunk/include/clang/Tooling/Core/Replacement.h
cfe/trunk/lib/Tooling/Core/Replacement.cpp
cfe/trunk/unittests/Tooling/RefactoringTest.cpp
Modified: cfe/trunk/include/clang/Tooling/Core/Replacement.h
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Tooling/Core/Replacement.h?rev=273290&r1=273289&r2=273290&view=diff
==============================================================================
--- cfe/trunk/include/clang/Tooling/Core/Replacement.h (original)
+++ cfe/trunk/include/clang/Tooling/Core/Replacement.h Tue Jun 21 12:56:31 2016
@@ -57,6 +57,11 @@ public:
return RHS.Offset >= Offset &&
(RHS.Offset + RHS.Length) <= (Offset + Length);
}
+
+ /// \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 +227,25 @@ bool applyAllReplacements(const std::vec
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<Range> 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<Range>
+calculateRangesAfterReplacements(const Replacements &Replaces,
+ const std::vector<Range> &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<std::string, Replacements>
Modified: cfe/trunk/lib/Tooling/Core/Replacement.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Tooling/Core/Replacement.cpp?rev=273290&r1=273289&r2=273290&view=diff
==============================================================================
--- cfe/trunk/lib/Tooling/Core/Replacement.cpp (original)
+++ cfe/trunk/lib/Tooling/Core/Replacement.cpp Tue Jun 21 12:56:31 2016
@@ -278,6 +278,30 @@ std::string applyAllReplacements(StringR
return Result;
}
+// Merge and sort overlapping ranges in \p Ranges.
+static std::vector<Range> mergeAndSortRanges(std::vector<Range> Ranges) {
+ std::sort(Ranges.begin(), Ranges.end(),
+ [](const Range &LHS, const Range &RHS) {
+ if (LHS.getOffset() != RHS.getOffset())
+ return LHS.getOffset() < RHS.getOffset();
+ return LHS.getLength() < RHS.getLength();
+ });
+ std::vector<Range> Result;
+ for (const auto &R : Ranges) {
+ if (Result.empty() ||
+ Result.back().getOffset() + Result.back().getLength() < R.getOffset()) {
+ Result.push_back(R);
+ } else {
+ unsigned NewEnd =
+ std::max(Result.back().getOffset() + Result.back().getLength(),
+ R.getOffset() + R.getLength());
+ Result[Result.size() - 1] =
+ Range(Result.back().getOffset(), NewEnd - Result.back().getOffset());
+ }
+ }
+ return Result;
+}
+
std::vector<Range> calculateChangedRanges(const Replacements &Replaces) {
std::vector<Range> ChangedRanges;
int Shift = 0;
@@ -287,7 +311,20 @@ std::vector<Range> calculateChangedRange
Shift += Length - R.getLength();
ChangedRanges.push_back(Range(Offset, Length));
}
- return ChangedRanges;
+ return mergeAndSortRanges(ChangedRanges);
+}
+
+std::vector<Range>
+calculateRangesAfterReplacements(const Replacements &Replaces,
+ const std::vector<Range> &Ranges) {
+ auto MergedRanges = mergeAndSortRanges(Ranges);
+ tooling::Replacements FakeReplaces;
+ for (const auto &R : MergedRanges)
+ 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 +471,3 @@ Replacements mergeReplacements(const Rep
} // end namespace tooling
} // end namespace clang
-
Modified: cfe/trunk/unittests/Tooling/RefactoringTest.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/unittests/Tooling/RefactoringTest.cpp?rev=273290&r1=273289&r2=273290&view=diff
==============================================================================
--- cfe/trunk/unittests/Tooling/RefactoringTest.cpp (original)
+++ cfe/trunk/unittests/Tooling/RefactoringTest.cpp Tue Jun 21 12:56:31 2016
@@ -462,13 +462,96 @@ TEST(Range, CalculateRangesOfReplacement
std::vector<Range> 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<Range> Ranges = {Range(5, 2), Range(10, 5)};
+ Replacements Replaces = {Replacement("foo", 0, 2, "1234")};
+ std::vector<Range> Expected = {Range(0, 4), Range(7, 2), Range(12, 5)};
+ EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
+}
+
+TEST(Range, RangesBeforeReplacements) {
+ std::vector<Range> Ranges = {Range(5, 2), Range(10, 5)};
+ Replacements Replaces = {Replacement("foo", 20, 2, "1234")};
+ std::vector<Range> Expected = {Range(5, 2), Range(10, 5), Range(20, 4)};
+ EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
+}
+
+TEST(Range, NotAffectedByReplacements) {
+ std::vector<Range> 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<Range> Expected = {Range(0, 2), Range(3, 4), Range(10, 5),
+ Range(20, 0)};
+ EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
+}
+
+TEST(Range, RangesWithNonOverlappingReplacements) {
+ std::vector<Range> 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<Range> 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<Range> 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<Range> Expected = {Range(0, 1), Range(2, 4), Range(12, 5),
+ Range(22, 0)};
+ EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
+}
+
+TEST(Range, MergeIntoOneRange) {
+ std::vector<Range> Ranges = {Range(0, 2), Range(5, 2), Range(15, 5)};
+ Replacements Replaces = {Replacement("foo", 1, 15, "1234567890")};
+ std::vector<Range> Expected = {Range(0, 15)};
+ EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
+}
+
+TEST(Range, ReplacementsStartingAtRangeOffsets) {
+ std::vector<Range> 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<Range> Expected = {Range(0, 2), Range(5, 9), Range(18, 2)};
+ EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
+}
+
+TEST(Range, ReplacementsEndingAtRangeEnds) {
+ std::vector<Range> Ranges = {Range(0, 2), Range(5, 2), Range(15, 5)};
+ Replacements Replaces = {Replacement("foo", 6, 1, "123"),
+ Replacement("foo", 17, 3, "12")};
+ std::vector<Range> Expected = {Range(0, 2), Range(5, 4), Range(17, 4)};
+ EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
+}
+
+TEST(Range, AjacentReplacements) {
+ std::vector<Range> Ranges = {Range(0, 0), Range(15, 5)};
+ Replacements Replaces = {Replacement("foo", 1, 2, "123"),
+ Replacement("foo", 12, 3, "1234")};
+ std::vector<Range> Expected = {Range(0, 0), Range(1, 3), Range(13, 9)};
+ EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
+}
+
+TEST(Range, MergeRangesAfterReplacements) {
+ std::vector<Range> 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<Range> Expected = {Range(0, 1), Range(2, 4), Range(7, 0), Range(8, 0)};
+ EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
}
TEST(DeduplicateTest, removesDuplicates) {
More information about the cfe-commits
mailing list