Make tooling::applyAllReplacements return llvm::Expected<string> instead of empty string to indicate potential error.

[ioeric]

Summary

return llvm::Expected<> to carry error status and error information.
This is the first step towards introducing "Error" into tooling::Replacements.

[klimek]

include/clang/Tooling/Core/Replacement.h

170

When I read "result code" I imagine a number.
Perhaps "returns the code with the replacements applied"
or "resulting code"?

lib/Format/Format.cpp

1395

Why would we want to return the same replacements?

[ioeric]

lib/Format/Format.cpp

1395

this is just a temp solution to keep the current interfaces of processReplacements and formatReplacements...should I add a FIXME or can I change them in this patch as well?

[klimek]

lib/Format/Format.cpp

1395

Both are good options :) Choose one.

[ioeric]

• fixed commenting.
• Make formatReplacemnts and cleanupAroundReplacements return llvm::Exppected<...>.

[ioeric]

mark previous comments as done

[klimek]

include/clang/Format/Format.h

780 ↗

(On Diff #61780)

typo: otheriwse

lib/Format/Format.cpp

1395–1396

Comment doesn't apply any more, right?

unittests/Format/CleanupTest.cpp

259

The explicit cast is unfortunate. Does this not have an .Ok() method or something?

[ioeric]

unittests/Format/CleanupTest.cpp

259

unfortunately, the bool operator is the only way we got...

I think the idea is that Errors are always expected to be checked and handled (the destructor of llvm::Error asserts that an Error has been handled).

[ioeric]

• Addressed comments.

[klimek]

unittests/Format/CleanupTest.cpp

259

Hm. Can we make it work with EXPECT_TRUE somehow?

[ioeric]

Would EXPECTED_FALSE(!Code) be better?

[klimek]

In D21601#466513, @ioeric wrote:

Would EXPECTED_FALSE(!Code) be better?

Not really. Can we at least use static_cast<bool>(...)?

[ioeric]

• Addressed reviewer's comments

[ioeric]

Friendly ping

[ioeric]

Ping

[ioeric]

PING

[klimek]

lg

include/clang/Tooling/Core/Replacement.h

 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLING_CORE_REPLACEMENT_H
 #define LLVM_CLANG_TOOLING_CORE_REPLACEMENT_H
 
 #include "clang/Basic/LangOptions.h"
 #include "clang/Basic/SourceLocation.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Error.h"
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
 namespace clang {
 
 class Rewriter;

 /// other applications.
 ///
 /// \returns true if all replacements apply. false otherwise.
 bool applyAllReplacements(const std::vector<Replacement> &Replaces,
                           Rewriter &Rewrite);
 
 /// \brief Applies all replacements in \p Replaces to \p Code.
 ///
-/// This completely ignores the path stored in each replacement. If one or more
-/// replacements cannot be applied, this returns an empty \c string.
-std::string applyAllReplacements(StringRef Code, const Replacements &Replaces);
+/// This completely ignores the path stored in each replacement. If all
+/// replacements are applied successfully, this returns the result code;
+/// otherwise, an llvm::Error carrying llvm::StringError is returned (the Error
+/// message can be converted to string using `llvm::toString()` and
+/// 'std::error_code` in the `Error` should be ignored).
+llvm::Expected<std::string> applyAllReplacements(StringRef Code,
+                                                 const Replacements &Replaces);
 
 /// \brief Calculates how a code \p Position is shifted when \p Replaces are
 /// applied.
 unsigned shiftedCodePosition(const Replacements& Replaces, unsigned Position);
 
 /// \brief Calculates how a code \p Position is shifted when \p Replaces are
 /// applied.
 ///
struct TranslationUnitReplacements {
   /// A freeform chunk of text to describe the context of the replacements.
   /// Will be printed, for example, when detecting conflicts during replacement
   /// deduplication.
   std::string Context;
 
   std::vector<Replacement> Replacements;
 };
 
-/// \brief Apply all replacements in \p Replaces to the Rewriter \p Rewrite.
-///
-/// Replacement applications happen independently of the success of
-/// other applications.
-///
-/// \returns true if all replacements apply. false otherwise.
-bool applyAllReplacements(const Replacements &Replaces, Rewriter &Rewrite);
-
-/// \brief Apply all replacements in \p Replaces to the Rewriter \p Rewrite.
-///
-/// Replacement applications happen independently of the success of
-/// other applications.
-///
-/// \returns true if all replacements apply. false otherwise.
-bool applyAllReplacements(const std::vector<Replacement> &Replaces,
-                          Rewriter &Rewrite);
-
-/// \brief Applies all replacements in \p Replaces to \p Code.
-///
-/// This completely ignores the path stored in each replacement. If one or more
-/// replacements cannot be applied, this returns an empty \c string.
-std::string applyAllReplacements(StringRef Code, const Replacements &Replaces);
-
 /// \brief Calculates the ranges in a single file that are affected by the
 /// 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);
 

lib/Format/Format.cpp

tooling::Replacements sortIncludes(const FormatStyle &Style, StringRef Code,
   if (!Style.SortIncludes)
     return Replaces;
   if (Style.Language == FormatStyle::LanguageKind::LK_JavaScript)
     return sortJavaScriptImports(Style, Code, Ranges, FileName);
   sortCppIncludes(Style, Code, Ranges, FileName, Replaces, Cursor);
   return Replaces;
 }
 
+// If any replacements in \p Replaces fails to apply, this returns \p Replaces.
 template <typename T>
 static tooling::Replacements
 processReplacements(T ProcessFunc, StringRef Code,
                     const tooling::Replacements &Replaces,
                     const FormatStyle &Style) {
   if (Replaces.empty())
     return tooling::Replacements();
 
-  std::string NewCode = applyAllReplacements(Code, Replaces);
+  auto NewCode = applyAllReplacements(Code, Replaces);
+  if (!NewCode) {
+    llvm::errs() << llvm::toString(NewCode.takeError()) << "\n";
+    return Replaces;
+  }
   std::vector<tooling::Range> ChangedRanges =
       tooling::calculateChangedRanges(Replaces);
   StringRef FileName = Replaces.begin()->getFilePath();
 
   tooling::Replacements FormatReplaces =
-      ProcessFunc(Style, NewCode, ChangedRanges, FileName);
+      ProcessFunc(Style, *NewCode, ChangedRanges, FileName);
 
   return mergeReplacements(Replaces, FormatReplaces);
 }
 
 tooling::Replacements formatReplacements(StringRef Code,
                                          const tooling::Replacements &Replaces,
                                          const FormatStyle &Style) {
   // We need to use lambda function here since there are two versions of

lib/Tooling/Core/Replacement.cpp

if (I->isApplicable()) {
       Result = I->apply(Rewrite) && Result;
     } else {
       Result = false;
     }
   }
   return Result;
 }
 
-std::string applyAllReplacements(StringRef Code, const Replacements &Replaces) {
-  if (Replaces.empty()) return Code;
+llvm::Expected<std::string> applyAllReplacements(StringRef Code,
+                                                const Replacements &Replaces) {
+  if (Replaces.empty())
+    return Code.str();
 
   IntrusiveRefCntPtr<vfs::InMemoryFileSystem> InMemoryFileSystem(
       new vfs::InMemoryFileSystem);
   FileManager Files(FileSystemOptions(), InMemoryFileSystem);
   DiagnosticsEngine Diagnostics(
       IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs),
       new DiagnosticOptions);
   SourceManager SourceMgr(Diagnostics, Files);
   Rewriter Rewrite(SourceMgr, LangOptions());
   InMemoryFileSystem->addFile(
       "<stdin>", 0, llvm::MemoryBuffer::getMemBuffer(Code, "<stdin>"));
   FileID ID = SourceMgr.createFileID(Files.getFile("<stdin>"), SourceLocation(),
                                      clang::SrcMgr::C_User);
   for (Replacements::const_iterator I = Replaces.begin(), E = Replaces.end();
        I != E; ++I) {
     Replacement Replace("<stdin>", I->getOffset(), I->getLength(),
                         I->getReplacementText());
     if (!Replace.apply(Rewrite))
-      return "";
+      return llvm::make_error<llvm::StringError>(
+          "Failed to apply replacement: " + Replace.toString(),
+          llvm::inconvertibleErrorCode());
   }
   std::string Result;
   llvm::raw_string_ostream OS(Result);
   Rewrite.getEditBuffer(ID).write(OS);
   OS.flush();
   return Result;
 }
 

tools/clang-format/ClangFormat.cpp

if (fillRanges(Code.get(), Ranges))
     return true;
   StringRef AssumedFileName = (FileName == "-") ? AssumeFileName : FileName;
   FormatStyle FormatStyle = getStyle(Style, AssumedFileName, FallbackStyle);
   if (SortIncludes.getNumOccurrences() != 0)
     FormatStyle.SortIncludes = SortIncludes;
   unsigned CursorPosition = Cursor;
   Replacements Replaces = sortIncludes(FormatStyle, Code->getBuffer(), Ranges,
                                        AssumedFileName, &CursorPosition);
-  std::string ChangedCode =
-      tooling::applyAllReplacements(Code->getBuffer(), Replaces);
+  auto ChangedCode = tooling::applyAllReplacements(Code->getBuffer(), Replaces);
+  if (!ChangedCode) {
+    llvm::errs() << llvm::toString(ChangedCode.takeError()) << "\n";
+    return true;
+  }
   for (const auto &R : Replaces)
     Ranges.push_back({R.getOffset(), R.getLength()});
 
   bool IncompleteFormat = false;
-  Replacements FormatChanges = reformat(FormatStyle, ChangedCode, Ranges,
+  Replacements FormatChanges = reformat(FormatStyle, *ChangedCode, Ranges,
                                         AssumedFileName, &IncompleteFormat);
   Replaces = tooling::mergeReplacements(Replaces, FormatChanges);
   if (OutputXML) {
     outs() << "<?xml version='1.0'?>\n<replacements "
               "xml:space='preserve' incomplete_format='"
            << (IncompleteFormat ? "true" : "false") << "'>\n";
     if (Cursor.getNumOccurrences() != 0)
       outs() << "<cursor>"

unittests/Format/CleanupTest.cpp

 
 class CleanupTest : public ::testing::Test {
 protected:
   std::string cleanup(llvm::StringRef Code,
                       const std::vector<tooling::Range> &Ranges,
                       const FormatStyle &Style = getLLVMStyle()) {
     tooling::Replacements Replaces = format::cleanup(Style, Code, Ranges);
 
-    std::string Result = applyAllReplacements(Code, Replaces);
-    EXPECT_NE("", Result);
-    return Result;
+    auto Result = applyAllReplacements(Code, Replaces);
+    EXPECT_TRUE((bool)Result);
+    return *Result;
   }
 };
 
 TEST_F(CleanupTest, DeleteEmptyNamespaces) {
   std::string Code = "namespace A {\n"
                      "namespace B {\n"
                      "} // namespace B\n"
                      "} // namespace A\n\n"
protected:
   }
 
   tooling::Replacement createInsertion(StringRef HeaderName) {
     return createReplacement(UINT_MAX, 0, HeaderName);
   }
 
   inline std::string apply(StringRef Code,
                            const tooling::Replacements Replaces) {
-    return applyAllReplacements(
+    auto Result = applyAllReplacements(
         Code, cleanupAroundReplacements(Code, Replaces, Style));
+    EXPECT_TRUE((bool)Result);
+    return *Result;
   }
 
   inline std::string formatAndApply(StringRef Code,
                                     const tooling::Replacements Replaces) {
-    return applyAllReplacements(
+    auto Result = applyAllReplacements(
         Code,
         formatReplacements(
             Code, cleanupAroundReplacements(Code, Replaces, Style), Style));
+    EXPECT_TRUE((bool)Result);
+    return *Result;
   }
 
   int getOffset(StringRef Code, int Line, int Column) {
     RewriterTestContext Context;
     FileID ID = Context.createInMemoryFile(FileName, Code);
     auto DecomposedLocation =
         Context.Sources.getDecomposedLoc(Context.getLocation(ID, Line, Column));
     return DecomposedLocation.second;

unittests/Format/FormatTest.cpp

std::string format(llvm::StringRef Code,
     bool IncompleteFormat = false;
     tooling::Replacements Replaces =
         reformat(Style, Code, Ranges, "<stdin>", &IncompleteFormat);
     if (CheckIncomplete != IC_DoNotCheck) {
       bool ExpectedIncompleteFormat = CheckIncomplete == IC_ExpectIncomplete;
       EXPECT_EQ(ExpectedIncompleteFormat, IncompleteFormat) << Code << "\n\n";
     }
     ReplacementCount = Replaces.size();
-    std::string Result = applyAllReplacements(Code, Replaces);
-    EXPECT_NE("", Result);
-    DEBUG(llvm::errs() << "\n" << Result << "\n\n");
-    return Result;
+    auto Result = applyAllReplacements(Code, Replaces);
+    EXPECT_TRUE((bool)Result);
+    DEBUG(llvm::errs() << "\n" << *Result << "\n\n");
+    return *Result;
   }
 
   FormatStyle getLLVMStyleWithColumns(unsigned ColumnLimit) {
     FormatStyle Style = getLLVMStyle();
     Style.ColumnLimit = ColumnLimit;
     return Style;
   }
 
Replaces.insert(tooling::Replacement(
       Context.Sources, Context.getLocation(ID, 3, 10), 1, "nullptr"));
   Replaces.insert(tooling::Replacement(
       Context.Sources, Context.getLocation(ID, 4, 3), 1, "nullptr"));
   Replaces.insert(tooling::Replacement(
       Context.Sources, Context.getLocation(ID, 4, 13), 1, "nullptr"));
 
   format::FormatStyle Style = format::getLLVMStyle();
   Style.ColumnLimit = 20; // Set column limit to 20 to increase readibility.
-  EXPECT_EQ(Expected, applyAllReplacements(
-                          Code, formatReplacements(Code, Replaces, Style)));
+  auto Result =
+      applyAllReplacements(Code, formatReplacements(Code, Replaces, Style));
+  EXPECT_TRUE((bool)Result);
+  EXPECT_EQ(Expected, *Result);
 }
 
 TEST_F(ReplacementTest, SortIncludesAfterReplacement) {
   std::string Code = "#include \"a.h\"\n"
                      "#include \"c.h\"\n"
                      "\n"
                      "int main() {\n"
                      "  return 0;\n"
                      "}";
   std::string Expected = "#include \"a.h\"\n"
                          "#include \"b.h\"\n"
                          "#include \"c.h\"\n"
                          "\n"
                          "int main() {\n"
                          "  return 0;\n"
                          "}";
   FileID ID = Context.createInMemoryFile("fix.cpp", Code);
   tooling::Replacements Replaces;
   Replaces.insert(tooling::Replacement(
       Context.Sources, Context.getLocation(ID, 1, 1), 0, "#include \"b.h\"\n"));
 
   format::FormatStyle Style = format::getLLVMStyle();
   Style.SortIncludes = true;
-  auto FinalReplaces = formatReplacements(Code, Replaces, Style);
-  EXPECT_EQ(Expected, applyAllReplacements(Code, FinalReplaces));
+  auto Result =
+      applyAllReplacements(Code, formatReplacements(Code, Replaces, Style));
+  EXPECT_TRUE((bool)Result);
+  EXPECT_EQ(Expected, *Result);
 }
 
 } // end namespace
 } // end namespace format
 } // end namespace clang

unittests/Format/FormatTestJS.cpp

static std::string format(llvm::StringRef Code, unsigned Offset,
                             unsigned Length, const FormatStyle &Style) {
     DEBUG(llvm::errs() << "---\n");
     DEBUG(llvm::errs() << Code << "\n\n");
     std::vector<tooling::Range> Ranges(1, tooling::Range(Offset, Length));
     bool IncompleteFormat = false;
     tooling::Replacements Replaces =
         reformat(Style, Code, Ranges, "<stdin>", &IncompleteFormat);
     EXPECT_FALSE(IncompleteFormat);
-    std::string Result = applyAllReplacements(Code, Replaces);
-    EXPECT_NE("", Result);
-    DEBUG(llvm::errs() << "\n" << Result << "\n\n");
-    return Result;
+    auto Result = applyAllReplacements(Code, Replaces);
+    EXPECT_TRUE((bool)Result);
+    DEBUG(llvm::errs() << "\n" << *Result << "\n\n");
+    return *Result;
   }
 
   static std::string format(
       llvm::StringRef Code,
       const FormatStyle &Style = getGoogleStyle(FormatStyle::LK_JavaScript)) {
     return format(Code, 0, Code.size(), Style);
   }
 

unittests/Format/FormatTestJava.cpp

 class FormatTestJava : public ::testing::Test {
 protected:
   static std::string format(llvm::StringRef Code, unsigned Offset,
                             unsigned Length, const FormatStyle &Style) {
     DEBUG(llvm::errs() << "---\n");
     DEBUG(llvm::errs() << Code << "\n\n");
     std::vector<tooling::Range> Ranges(1, tooling::Range(Offset, Length));
     tooling::Replacements Replaces = reformat(Style, Code, Ranges);
-    std::string Result = applyAllReplacements(Code, Replaces);
-    EXPECT_NE("", Result);
-    DEBUG(llvm::errs() << "\n" << Result << "\n\n");
-    return Result;
+    auto Result = applyAllReplacements(Code, Replaces);
+    EXPECT_TRUE((bool)Result);
+    DEBUG(llvm::errs() << "\n" << *Result << "\n\n");
+    return *Result;
   }
 
   static std::string
   format(llvm::StringRef Code,
          const FormatStyle &Style = getGoogleStyle(FormatStyle::LK_Java)) {
     return format(Code, 0, Code.size(), Style);
   }
 

unittests/Format/FormatTestProto.cpp

 class FormatTestProto : public ::testing::Test {
 protected:
   static std::string format(llvm::StringRef Code, unsigned Offset,
                             unsigned Length, const FormatStyle &Style) {
     DEBUG(llvm::errs() << "---\n");
     DEBUG(llvm::errs() << Code << "\n\n");
     std::vector<tooling::Range> Ranges(1, tooling::Range(Offset, Length));
     tooling::Replacements Replaces = reformat(Style, Code, Ranges);
-    std::string Result = applyAllReplacements(Code, Replaces);
-    EXPECT_NE("", Result);
-    DEBUG(llvm::errs() << "\n" << Result << "\n\n");
-    return Result;
+    auto Result = applyAllReplacements(Code, Replaces);
+    EXPECT_TRUE((bool)Result);
+    DEBUG(llvm::errs() << "\n" << *Result << "\n\n");
+    return *Result;
   }
 
   static std::string format(llvm::StringRef Code) {
     FormatStyle Style = getGoogleStyle(FormatStyle::LK_Proto);
     Style.ColumnLimit = 60; // To make writing tests easier.
     return format(Code, 0, Code.size(), Style);
   }
 

unittests/Format/FormatTestSelective.cpp

protected:
   std::string format(llvm::StringRef Code, unsigned Offset, unsigned Length) {
     DEBUG(llvm::errs() << "---\n");
     DEBUG(llvm::errs() << Code << "\n\n");
     std::vector<tooling::Range> Ranges(1, tooling::Range(Offset, Length));
     bool IncompleteFormat = false;
     tooling::Replacements Replaces =
         reformat(Style, Code, Ranges, "<stdin>", &IncompleteFormat);
     EXPECT_FALSE(IncompleteFormat) << Code << "\n\n";
-    std::string Result = applyAllReplacements(Code, Replaces);
-    EXPECT_NE("", Result);
-    DEBUG(llvm::errs() << "\n" << Result << "\n\n");
-    return Result;
+    auto Result = applyAllReplacements(Code, Replaces);
+    EXPECT_TRUE((bool)Result);
+    DEBUG(llvm::errs() << "\n" << *Result << "\n\n");
+    return *Result;
   }
 
   FormatStyle Style = getLLVMStyle();
 };
 
 TEST_F(FormatTestSelective, RemovesTrailingWhitespaceOfFormattedLine) {
   EXPECT_EQ("int a;\nint b;", format("int a; \nint b;", 0, 0));
   EXPECT_EQ("int a;", format("int a;         ", 0, 0));

unittests/Format/SortImportsTestJS.cpp

 
 class SortImportsTestJS : public ::testing::Test {
 protected:
   std::string sort(StringRef Code, unsigned Offset = 0, unsigned Length = 0) {
     StringRef FileName = "input.js";
     if (Length == 0U)
       Length = Code.size() - Offset;
     std::vector<tooling::Range> Ranges(1, tooling::Range(Offset, Length));
-    std::string Sorted =
+    auto Sorted =
         applyAllReplacements(Code, sortIncludes(Style, Code, Ranges, FileName));
-    return applyAllReplacements(Sorted,
-                                reformat(Style, Sorted, Ranges, FileName));
+    EXPECT_TRUE((bool)Sorted);
+    auto Formatted = applyAllReplacements(
+        *Sorted, reformat(Style, *Sorted, Ranges, FileName));
+    EXPECT_TRUE((bool)Formatted);
+    return *Formatted;
   }
 
   void verifySort(llvm::StringRef Expected, llvm::StringRef Code,
                   unsigned Offset = 0, unsigned Length = 0) {
     std::string Result = sort(Code, Offset, Length);
     EXPECT_EQ(Expected.str(), Result) << "Expected:\n"
                                       << Expected << "\nActual:\n"
                                       << Result;

unittests/Format/SortIncludesTest.cpp

 class SortIncludesTest : public ::testing::Test {
 protected:
   std::vector<tooling::Range> GetCodeRange(StringRef Code) {
     return std::vector<tooling::Range>(1, tooling::Range(0, Code.size()));
   }
 
   std::string sort(StringRef Code, StringRef FileName = "input.cpp") {
     auto Ranges = GetCodeRange(Code);
-    std::string Sorted =
+    auto Sorted =
         applyAllReplacements(Code, sortIncludes(Style, Code, Ranges, FileName));
-    return applyAllReplacements(Sorted,
-                                reformat(Style, Sorted, Ranges, FileName));
+    EXPECT_TRUE((bool)Sorted);
+    auto Result = applyAllReplacements(
+        *Sorted, reformat(Style, *Sorted, Ranges, FileName));
+    EXPECT_TRUE((bool)Result);
+    return *Result;
   }
 
   unsigned newCursor(llvm::StringRef Code, unsigned Cursor) {
     sortIncludes(Style, Code, GetCodeRange(Code), "input.cpp", &Cursor);
     return Cursor;
   }
 
   FormatStyle Style = getLLVMStyle();

unittests/Tooling/RefactoringTest.cpp

 }
 
 class MergeReplacementsTest : public ::testing::Test {
 protected:
   void mergeAndTestRewrite(StringRef Code, StringRef Intermediate,
                            StringRef Result, const Replacements &First,
                            const Replacements &Second) {
     // These are mainly to verify the test itself and make it easier to read.
-    std::string AfterFirst = applyAllReplacements(Code, First);
-    std::string InSequenceRewrite = applyAllReplacements(AfterFirst, Second);
-    EXPECT_EQ(Intermediate, AfterFirst);
-    EXPECT_EQ(Result, InSequenceRewrite);
+    auto AfterFirst = applyAllReplacements(Code, First);
+    EXPECT_TRUE((bool)AfterFirst);
+    auto InSequenceRewrite = applyAllReplacements(*AfterFirst, Second);
+    EXPECT_TRUE((bool)InSequenceRewrite);
+    EXPECT_EQ(Intermediate, *AfterFirst);
+    EXPECT_EQ(Result, *InSequenceRewrite);
 
     tooling::Replacements Merged = mergeReplacements(First, Second);
-    std::string MergedRewrite = applyAllReplacements(Code, Merged);
-    EXPECT_EQ(InSequenceRewrite, MergedRewrite);
-    if (InSequenceRewrite != MergedRewrite)
+    auto MergedRewrite = applyAllReplacements(Code, Merged);
+    EXPECT_TRUE((bool)MergedRewrite);
+    EXPECT_EQ(*InSequenceRewrite, *MergedRewrite);
+    if (*InSequenceRewrite != *MergedRewrite)
       for (tooling::Replacement M : Merged)
         llvm::errs() << M.getOffset() << " " << M.getLength() << " "
                      << M.getReplacementText() << "\n";
   }
   void mergeAndTestRewrite(StringRef Code, const Replacements &First,
                            const Replacements &Second) {
-    std::string InSequenceRewrite =
-        applyAllReplacements(applyAllReplacements(Code, First), Second);
+    auto AfterFirst = applyAllReplacements(Code, First);
+    EXPECT_TRUE((bool)AfterFirst);
+    auto InSequenceRewrite = applyAllReplacements(*AfterFirst, Second);
     tooling::Replacements Merged = mergeReplacements(First, Second);
-    std::string MergedRewrite = applyAllReplacements(Code, Merged);
-    EXPECT_EQ(InSequenceRewrite, MergedRewrite);
-    if (InSequenceRewrite != MergedRewrite)
+    auto MergedRewrite = applyAllReplacements(Code, Merged);
+    EXPECT_TRUE((bool)MergedRewrite);
+    EXPECT_EQ(*InSequenceRewrite, *MergedRewrite);
+    if (*InSequenceRewrite != *MergedRewrite)
       for (tooling::Replacement M : Merged)
         llvm::errs() << M.getOffset() << " " << M.getLength() << " "
                      << M.getReplacementText() << "\n";
   }
 };
 
 TEST_F(MergeReplacementsTest, Offsets) {
   mergeAndTestRewrite("aaa", "aabab", "cacabab",

unittests/Tooling/RewriterTest.cpp

TEST(Rewriter, ContinuesOverwritingFilesOnError) {
   EXPECT_EQ("line1\nreplaced\nline3\nline4",
             Context.getFileContentFromDisk("working.cpp")); 
 }
 
 TEST(Rewriter, AdjacentInsertAndDelete) {
   Replacements Replaces;
   Replaces.insert(Replacement("<file>", 6, 6, ""));
   Replaces.insert(Replacement("<file>", 6, 0, "replaced\n"));
-  EXPECT_EQ("line1\nreplaced\nline3\nline4",
-            applyAllReplacements("line1\nline2\nline3\nline4", Replaces));
+  auto Rewritten = applyAllReplacements("line1\nline2\nline3\nline4", Replaces);
+  EXPECT_TRUE((bool)Rewritten);
+  EXPECT_EQ("line1\nreplaced\nline3\nline4", *Rewritten);
 }
 
 } // end namespace
 } // end namespace tooling
 } // end namespace clang