Fixes calculateRangesAfterReplacements crash when Replacements is empty.

[djasper]

Looks good.

lib/Tooling/Core/Replacement.cpp

 calculateRangesAfterReplacements(const Replacements &Replaces,
                                  const std::vector<Range> &Ranges) {
   // To calculate the new ranges,
   //   - Turn \p Ranges into Replacements at (offset, length) with an empty
   //     (unimportant) replacement text of length "length".
   //   - Merge with \p Replaces.
   //   - The new ranges will be the affected ranges of the merged replacements.
   auto MergedRanges = combineAndSortRanges(Ranges);
+  if (Replaces.empty())
+    return MergedRanges;
   tooling::Replacements FakeReplaces;
   for (const auto &R : MergedRanges) {
     auto Err = FakeReplaces.add(Replacement(Replaces.begin()->getFilePath(),
                                             R.getOffset(), R.getLength(),
                                             std::string(R.getLength(), ' ')));
     assert(!Err &&
            "Replacements must not conflict since ranges have been merged.");
     (void)Err;

unittests/Tooling/RefactoringTest.cpp

TEST(Range, CalculateRangesOfReplacements) {
 
   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() == 22);
 }
 
+TEST(Range, RangesAfterEmptyReplacements) {
+  std::vector<Range> Ranges = {Range(5, 6), Range(10, 5)};
+  Replacements Replaces;
+  std::vector<Range> Expected = {Range(5, 10)};
+  EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
+}
+
 TEST(Range, RangesAfterReplacements) {
   std::vector<Range> Ranges = {Range(5, 2), Range(10, 5)};
   Replacements Replaces = toReplacements({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) {