[RFC] Add a VCS conflict marker format printing on tooling::ReplacementError

[jdemeule]

Summary

Last year, I made some suggestion to improve conflict reporting in clang-apply-replacements (https://reviews.llvm.org/D43764).
I have a very simple implementation of a VCS conflict marker to share and get some feedbacks if this approach could get some interests.

[jdemeule]

Kindly ping reviewers and adding Eric as you were interested last year about that.

[jdemeule]

Kindly ping reviewers.

[jdemeule]

Kindly ping reviewers.

clang-tools-extra/clang-apply-replacements/lib/Tooling/ApplyReplacements.cpp

for (const auto &FileAndReplacements : GroupedReplacements) {
     const SourceLocation BeginLoc =
         SM.getLocForStartOfFile(SM.getOrCreateFileID(Entry, SrcMgr::C_User));
     tooling::AtomicChange FileChange(Entry->getName(), Entry->getName());
     for (const auto &R : FileAndReplacements.second) {
       llvm::Error Err =
           FileChange.replace(SM, BeginLoc.getLocWithOffset(R.getOffset()),
                              R.getLength(), R.getReplacementText());
       if (Err) {
-        // FIXME: This will report conflicts by pair using a file+offset format
-        // which is not so much human readable.
-        // A first improvement could be to translate offset to line+col. For
-        // this and without loosing error message some modifications arround
-        // `tooling::ReplacementError` are need (access to
-        // `getReplacementErrString`).
-        // A better strategy could be to add a pretty printer methods for
-        // conflict reporting. Methods that could be parameterized to report a
-        // conflict in different format, file+offset, file+line+col, or even
-        // more human readable using VCS conflict markers.
-        // For now, printing directly the error reported by `AtomicChange` is
-        // the easiest solution.
+        Err = llvm::handleErrors(std::move(Err),
+                                 [&](const tooling::ReplacementError &RE) {
+                                   RE.reportConflict(errs(), SM);
+                                   errs() << "\n";
+                                 });
+        if (Err)
           errs() << llvm::toString(std::move(Err)) << "\n";
         ConflictDetected = true;
       }
     }
     FileChanges.try_emplace(Entry,
                             std::vector<tooling::AtomicChange>{FileChange});
   }
 
   return !ConflictDetected;

clang-tools-extra/test/clang-apply-replacements/Inputs/conflict/expected.txt

-The new replacement overlaps with an existing replacement.
-New replacement: $(path)/common.h: 106:+26:"int & elem : ints"
-Existing replacement: $(path)/common.h: 106:+26:"auto & i : ints"
-The new replacement overlaps with an existing replacement.
-New replacement: $(path)/common.h: 140:+7:"i"
-Existing replacement: $(path)/common.h: 140:+7:"elem"
-The new replacement overlaps with an existing replacement.
-New replacement: $(path)/common.h: 169:+0:"(int*)"
-Existing replacement: $(path)/common.h: 160:+12:""
-The new replacement overlaps with an existing replacement.
-New replacement: $(path)/common.h: 169:+1:"nullptr"
-Existing replacement: $(path)/common.h: 160:+12:""
+$(path)/common.h:8:8-8:34
+<<<<<<< Existing replacement
+  for (auto & i : ints) {
+=======
+  for (int & elem : ints) {
+>>>>>>> New replacement
+
+$(path)/common.h:9:5-9:12
+<<<<<<< Existing replacement
+    elem = t;
+=======
+    i = t;
+>>>>>>> New replacement
+
+$(path)/common.h:12:3-13:1
+<<<<<<< Existing replacement
+
+=======
+  int *i = (int*)0;
+
+>>>>>>> New replacement
+
+$(path)/common.h:12:3-13:1
+<<<<<<< Existing replacement
+
+=======
+  int *i = nullptr;
+
+>>>>>>> New replacement
+

clang-tools-extra/test/clang-apply-replacements/Inputs/order-dependent/expected.txt

-The new insertion has the same insert location as an existing replacement.
-New replacement: $(path)/order-dependent.cpp: 12:+0:"1"
-Existing replacement: $(path)/order-dependent.cpp: 12:+0:"0"
+$(path)/order-dependent.cpp:1:13-1:13
+<<<<<<< Existing replacement
+class MyType0 {};
+=======
+class MyType1 {};
+>>>>>>> New replacement
+

clang/include/clang/Tooling/Core/Replacement.h

public:
   /// @}
 
   /// Applies the replacement on the Rewriter.
   bool apply(Rewriter &Rewrite) const;
 
   /// Returns a human readable string representation.
   std::string toString() const;
 
+  /// Print a human readable string representation where offset is converted
+  /// in line+col.
+  void print(raw_ostream &OS, const SourceManager &SM) const;
+
+  /// Returns a human readable string representation where offset is converted
+  /// in line+col.
+  std::string printToString(const SourceManager &SM) const;
+
 private:
   void setFromSourceLocation(const SourceManager &Sources, SourceLocation Start,
                              unsigned Length, StringRef ReplacementText);
   void setFromSourceRange(const SourceManager &Sources,
                           const CharSourceRange &Range,
                           StringRef ReplacementText,
                           const LangOptions &LangOpts);
 
public:
   const llvm::Optional<Replacement> &getNewReplacement() const {
     return NewReplacement;
   }
 
   const llvm::Optional<Replacement> &getExistingReplacement() const {
     return ExistingReplacement;
   }
 
+  /// Print a replacement conflict using conflict marker format.
+  void reportConflict(raw_ostream &OS, SourceManager &SM) const;
+
 private:
   // Users are not expected to use error_code.
   std::error_code convertToErrorCode() const override {
     return llvm::inconvertibleErrorCode();
   }
 
   replacement_error Err;
 
public:
   void clear() { Replaces.clear(); }
 
   bool empty() const { return Replaces.empty(); }
 
   const_iterator begin() const { return Replaces.begin(); }
 
   const_iterator end() const { return Replaces.end(); }
 
-  const_reverse_iterator rbegin() const  { return Replaces.rbegin(); }
+  const_reverse_iterator rbegin() const { return Replaces.rbegin(); }
 
   const_reverse_iterator rend() const { return Replaces.rend(); }
 
   bool operator==(const Replacements &RHS) const {
     return Replaces == RHS.Replaces;
   }
 
 private:

clang/lib/Tooling/Core/Replacement.cpp

 #include <map>
 #include <string>
 #include <utility>
 #include <vector>
 
 using namespace clang;
 using namespace tooling;
 
-static const char * const InvalidLocation = "";
+static const char *const InvalidLocation = "";
 
 Replacement::Replacement() : FilePath(InvalidLocation) {}
 
 Replacement::Replacement(StringRef FilePath, unsigned Offset, unsigned Length,
                          StringRef ReplacementText)
     : FilePath(FilePath), ReplacementRange(Offset, Length),
       ReplacementText(ReplacementText) {}
 
 Replacement::Replacement(const SourceManager &Sources, SourceLocation Start,
                          unsigned Length, StringRef ReplacementText) {
   setFromSourceLocation(Sources, Start, Length, ReplacementText);
 }
 
 Replacement::Replacement(const SourceManager &Sources,
                          const CharSourceRange &Range,
                          StringRef ReplacementText,
                          const LangOptions &LangOpts) {
   setFromSourceRange(Sources, Range, ReplacementText, LangOpts);
 }
 
-bool Replacement::isApplicable() const {
-  return FilePath != InvalidLocation;
-}
+bool Replacement::isApplicable() const { return FilePath != InvalidLocation; }
 
 bool Replacement::apply(Rewriter &Rewrite) const {
   SourceManager &SM = Rewrite.getSourceMgr();
   auto Entry = SM.getFileManager().getFile(FilePath);
   if (!Entry)
     return false;
 
   FileID ID = SM.getOrCreateFileID(*Entry, SrcMgr::C_User);
-  const SourceLocation Start =
-    SM.getLocForStartOfFile(ID).
-    getLocWithOffset(ReplacementRange.getOffset());
+  const SourceLocation Start = SM.getLocForStartOfFile(ID).getLocWithOffset(
+      ReplacementRange.getOffset());
   // ReplaceText returns false on success.
   // ReplaceText only fails if the source location is not a file location, in
   // which case we already returned false earlier.
   bool RewriteSucceeded = !Rewrite.ReplaceText(
       Start, ReplacementRange.getLength(), ReplacementText);
   assert(RewriteSucceeded);
   return RewriteSucceeded;
 }
 
 std::string Replacement::toString() const {
   std::string Result;
   llvm::raw_string_ostream Stream(Result);
   Stream << FilePath << ": " << ReplacementRange.getOffset() << ":+"
          << ReplacementRange.getLength() << ":\"" << ReplacementText << "\"";
   return Stream.str();
 }
 
+void Replacement::print(raw_ostream &OS, const SourceManager &SM) const {
+  auto Entry = SM.getFileManager().getFile(FilePath);
+  assert(File);
+  FileID ID = SM.translateFile(*Entry);
+  auto PrintOffsetPosition = [&](unsigned int Offset) {
+    OS << SM.getLineNumber(ID, Offset) << ":" << SM.getColumnNumber(ID, Offset);
+  };
+  OS << FilePath << ":";
+  PrintOffsetPosition(getOffset());
+  OS << "-";
+  PrintOffsetPosition(getOffset() + getLength());
+  OS << ":\"" << ReplacementText << "\"";
+}
+
+std::string Replacement::printToString(const SourceManager &SM) const {
+  std::string Result;
+  llvm::raw_string_ostream Stream(Result);
+  print(Stream, SM);
+  return Result;
+}
+
 namespace clang {
 namespace tooling {
 
 bool operator<(const Replacement &LHS, const Replacement &RHS) {
   if (LHS.getOffset() != RHS.getOffset())
     return LHS.getOffset() < RHS.getOffset();
 
   if (LHS.getLength() != RHS.getLength())

 // good way how to integrate this into the Lexer yet.
 static int getRangeSize(const SourceManager &Sources,
                         const CharSourceRange &Range,
                         const LangOptions &LangOpts) {
   SourceLocation SpellingBegin = Sources.getSpellingLoc(Range.getBegin());
   SourceLocation SpellingEnd = Sources.getSpellingLoc(Range.getEnd());
   std::pair<FileID, unsigned> Start = Sources.getDecomposedLoc(SpellingBegin);
   std::pair<FileID, unsigned> End = Sources.getDecomposedLoc(SpellingEnd);
-  if (Start.first != End.first) return -1;
+  if (Start.first != End.first)
+    return -1;
   if (Range.isTokenRange())
     End.second += Lexer::MeasureTokenLength(SpellingEnd, Sources, LangOpts);
   return End.second - Start.second;
 }
 
 void Replacement::setFromSourceRange(const SourceManager &Sources,
                                      const CharSourceRange &Range,
                                      StringRef ReplacementText,
std::string ReplacementError::message() const {
   std::string Message = getReplacementErrString(Err);
   if (NewReplacement.hasValue())
     Message += "\nNew replacement: " + NewReplacement->toString();
   if (ExistingReplacement.hasValue())
     Message += "\nExisting replacement: " + ExistingReplacement->toString();
   return Message;
 }
 
+void ReplacementError::reportConflict(raw_ostream &OS,
+                                      SourceManager &SM) const {
+  if (Err == replacement_error::fail_to_apply ||
+      Err == replacement_error::wrong_file_path) {
+    OS << getReplacementErrString(Err);
+    if (NewReplacement.hasValue()) {
+      OS << "\nNew replacement: ";
+      NewReplacement->print(OS, SM);
+    }
+    if (ExistingReplacement.hasValue()) {
+      OS << "\nExisting replacement: ";
+      ExistingReplacement->print(OS, SM);
+    }
+    return;
+  }
+
+  auto Entry = SM.getFileManager().getFile(NewReplacement->getFilePath());
+  if (!Entry)
+    return;
+
+  FileID FID = SM.getOrCreateFileID(*Entry, SrcMgr::C_User);
+
+  // Compute the min an max offset of between the conflicting replacements.
+  // This range is enlarge to the corresponding line begin and end, then the
+  // text is extract.
+  unsigned int OffsetMin =
+      std::min(ExistingReplacement->getOffset(), NewReplacement->getOffset());
+  unsigned int OffsetMax = std::max(
+      ExistingReplacement->getOffset() + ExistingReplacement->getLength(),
+      NewReplacement->getOffset() + NewReplacement->getLength());
+  unsigned int BeginOffset =
+      SM.getDecomposedLoc(
+            SM.translateLineCol(FID, SM.getLineNumber(FID, OffsetMin), 1))
+          .second;
+  unsigned int EndOffset =
+      SM.getDecomposedLoc(
+            SM.translateLineCol(FID, SM.getLineNumber(FID, OffsetMax), 0))
+          .second;
+  StringRef Text = SM.getBuffer(FID)->getBuffer().slice(BeginOffset, EndOffset);
+
+  auto ReplacementText = [&](const tooling::Replacement &R) {
+    unsigned int StartOffset = R.getOffset() - BeginOffset;
+    unsigned int EndOffset = R.getOffset() + R.getLength() - BeginOffset;
+    std::string Buffer = Text;
+    Buffer.erase(Buffer.begin() + StartOffset, Buffer.begin() + EndOffset);
+    Buffer.insert(StartOffset, R.getReplacementText());
+    return Buffer;
+  };
+
+  auto PrintOffsetPosition = [&](unsigned int Offset) {
+    OS << SM.getLineNumber(FID, Offset) << ":"
+       << SM.getColumnNumber(FID, Offset);
+  };
+
+  // Apply existing and new replacement into the extracted text and print then
+  // within the conflict marker format and prefix everthing with filepath + file
+  // location range of the conflict.
+  OS << NewReplacement->getFilePath() << ":";
+  PrintOffsetPosition(OffsetMin);
+  OS << "-";
+  PrintOffsetPosition(OffsetMax);
+  OS << "\n"
+     << "<<<<<<< Existing replacement\n"
+     << ReplacementText(*ExistingReplacement) << "\n"
+     << "=======\n"
+     << ReplacementText(*NewReplacement) << "\n"
+     << ">>>>>>> New replacement\n";
+}
+
 char ReplacementError::ID = 0;
 
 Replacements Replacements::getCanonicalReplacements() const {
   std::vector<Replacement> NewReplaces;
   // Merge adjacent replacements.
   for (const auto &R : Replaces) {
     if (NewReplaces.empty()) {
       NewReplaces.push_back(R);

 // * We always merge elements from 'First' into elements from 'Second' and vice
 //   versa. Within each set, the replacements are non-overlapping.
 // * We only extend to the right, i.e. merge elements with strictly increasing
 //   offsets.
 class MergedReplacement {
 public:
   MergedReplacement(const Replacement &R, bool MergeSecond, int D)
       : MergeSecond(MergeSecond), Delta(D), FilePath(R.getFilePath()),
-        Offset(R.getOffset() + (MergeSecond ? 0 : Delta)), Length(R.getLength()),
-        Text(R.getReplacementText()) {
+        Offset(R.getOffset() + (MergeSecond ? 0 : Delta)),
+        Length(R.getLength()), Text(R.getReplacementText()) {
     Delta += MergeSecond ? 0 : Text.size() - Length;
     DeltaFirst = MergeSecond ? Text.size() - Length : 0;
   }
 
   // Merges the next element 'R' into this merged element. As we always merge
   // from 'First' into 'Second' or vice versa, the MergedReplacement knows what
   // set the next element is coming from.
   void merge(const Replacement &R) {
for (auto I = Replaces.rbegin(), E = Replaces.rend(); I != E; ++I) {
     } else {
       Result = false;
     }
   }
   return Result;
 }
 
 llvm::Expected<std::string> applyAllReplacements(StringRef Code,
                                                  const Replacements &Replaces) {
   if (Replaces.empty())
     return Code.str();
 
   IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> InMemoryFileSystem(
       new llvm::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);
+                                     SourceLocation(), clang::SrcMgr::C_User);
   for (auto I = Replaces.rbegin(), E = Replaces.rend(); I != E; ++I) {
     Replacement Replace("<stdin>", I->getOffset(), I->getLength(),
                         I->getReplacementText());
     if (!Replace.apply(Rewrite))
       return llvm::make_error<ReplacementError>(
           replacement_error::fail_to_apply, Replace);
   }
   std::string Result;

clang/unittests/Tooling/RefactoringTest.cpp

 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/LangOptions.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Format/Format.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/FrontendAction.h"
 #include "clang/Frontend/TextDiagnosticPrinter.h"
 #include "clang/Rewrite/Core/Rewriter.h"
+#include "clang/Tooling/Core/Replacement.h"
 #include "clang/Tooling/Refactoring/AtomicChange.h"
 #include "clang/Tooling/Tooling.h"
 #include "llvm/ADT/SmallString.h"
+#include "llvm/Support/Error.h"
 #include "llvm/Support/VirtualFileSystem.h"
+#include "llvm/Support/raw_ostream.h"
 #include "gtest/gtest.h"
 
 namespace clang {
 namespace tooling {
 
 TEST_F(ReplacementTest, CanDeleteAllText) {
   FileID ID = Context.createInMemoryFile("input.cpp", "text");
   SourceLocation Location = Context.getLocation(ID, 1, 1);
TEST_F(ReplacementTest, CanAddText) {
   FileID ID = Context.createInMemoryFile("input.cpp", "");
   SourceLocation Location = Context.getLocation(ID, 1, 1);
   Replacement Replace(createReplacement(Location, 0, "result"));
   EXPECT_TRUE(Replace.apply(Context.Rewrite));
   EXPECT_EQ("result", Context.getRewrittenText(ID));
 }
 
 TEST_F(ReplacementTest, CanReplaceTextAtPosition) {
-  FileID ID = Context.createInMemoryFile("input.cpp",
-                                         "line1\nline2\nline3\nline4");
+  FileID ID =
+      Context.createInMemoryFile("input.cpp", "line1\nline2\nline3\nline4");
   SourceLocation Location = Context.getLocation(ID, 2, 3);
   Replacement Replace(createReplacement(Location, 12, "x"));
   EXPECT_TRUE(Replace.apply(Context.Rewrite));
   EXPECT_EQ("line1\nlixne4", Context.getRewrittenText(ID));
 }
 
 TEST_F(ReplacementTest, CanReplaceTextAtPositionMultipleTimes) {
-  FileID ID = Context.createInMemoryFile("input.cpp",
-                                         "line1\nline2\nline3\nline4");
+  FileID ID =
+      Context.createInMemoryFile("input.cpp", "line1\nline2\nline3\nline4");
   SourceLocation Location1 = Context.getLocation(ID, 2, 3);
   Replacement Replace1(createReplacement(Location1, 12, "x\ny\n"));
   EXPECT_TRUE(Replace1.apply(Context.Rewrite));
   EXPECT_EQ("line1\nlix\ny\nne4", Context.getRewrittenText(ID));
 
   // Since the original source has not been modified, the (4, 4) points to the
   // 'e' in the original content.
   SourceLocation Location2 = Context.getLocation(ID, 4, 4);
if (ExpectedNew != RE.getNewReplacement()) {
       if (ExpectedNew.hasValue())
         OS << "Expected new replacement: " << ExpectedNew->toString() << "\n";
       if (RE.getNewReplacement().hasValue())
         OS << "Actual new replacement: " << RE.getNewReplacement()->toString()
            << "\n";
     }
   });
   OS.flush();
-  if (ErrorMessage.empty()) return true;
+  if (ErrorMessage.empty())
+    return true;
   llvm::errs() << ErrorMessage;
   return false;
 }
 
 TEST_F(ReplacementTest, FailAddReplacements) {
   Replacements Replaces;
   Replacement Deletion("x.cc", 0, 10, "3");
   auto Err = Replaces.add(Deletion);
TEST_F(ReplacementTest, InsertBetweenAdjacentReplacements) {
   EXPECT_TRUE(!Err);
   llvm::consumeError(std::move(Err));
   Err = Replaces.add(Replacement("x.cc", 10, 0, "b"));
   EXPECT_TRUE(!Err);
   llvm::consumeError(std::move(Err));
 }
 
 TEST_F(ReplacementTest, CanApplyReplacements) {
-  FileID ID = Context.createInMemoryFile("input.cpp",
-                                         "line1\nline2\nline3\nline4");
+  FileID ID =
+      Context.createInMemoryFile("input.cpp", "line1\nline2\nline3\nline4");
   Replacements Replaces =
       toReplacements({Replacement(Context.Sources,
                                   Context.getLocation(ID, 2, 1), 5, "replaced"),
                       Replacement(Context.Sources,
                                   Context.getLocation(ID, 3, 1), 5, "other")});
   EXPECT_TRUE(applyAllReplacements(Replaces, Context.Rewrite));
   EXPECT_EQ("line1\nreplaced\nother\nline4", Context.getRewrittenText(ID));
 }
 
 // Verifies that replacement/deletion is applied before insertion at the same
 // offset.
 TEST_F(ReplacementTest, InsertAndDelete) {
-  FileID ID = Context.createInMemoryFile("input.cpp",
-                                         "line1\nline2\nline3\nline4");
+  FileID ID =
+      Context.createInMemoryFile("input.cpp", "line1\nline2\nline3\nline4");
   Replacements Replaces = toReplacements(
       {Replacement(Context.Sources, Context.getLocation(ID, 2, 1), 6, ""),
        Replacement(Context.Sources, Context.getLocation(ID, 2, 1), 0,
                    "other\n")});
   EXPECT_TRUE(applyAllReplacements(Replaces, Context.Rewrite));
   EXPECT_EQ("line1\nother\nline3\nline4", Context.getRewrittenText(ID));
 }
 
 TEST_F(ReplacementTest, AdjacentReplacements) {
-  FileID ID = Context.createInMemoryFile("input.cpp",
-                                         "ab");
+  FileID ID = Context.createInMemoryFile("input.cpp", "ab");
   Replacements Replaces = toReplacements(
       {Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 1, "x"),
        Replacement(Context.Sources, Context.getLocation(ID, 1, 2), 1, "y")});
   EXPECT_TRUE(applyAllReplacements(Replaces, Context.Rewrite));
   EXPECT_EQ("xy", Context.getRewrittenText(ID));
 }
 
 TEST_F(ReplacementTest, AddDuplicateReplacements) {
-  FileID ID = Context.createInMemoryFile("input.cpp",
-                                         "line1\nline2\nline3\nline4");
+  FileID ID =
+      Context.createInMemoryFile("input.cpp", "line1\nline2\nline3\nline4");
   auto Replaces = toReplacements({Replacement(
       Context.Sources, Context.getLocation(ID, 2, 1), 5, "replaced")});
 
   auto Err = Replaces.add(Replacement(
       Context.Sources, Context.getLocation(ID, 2, 1), 5, "replaced"));
   EXPECT_TRUE(!Err);
   llvm::consumeError(std::move(Err));
 
   Err = Replaces.add(Replacement(Context.Sources, Context.getLocation(ID, 2, 1),
                                  5, "replaced"));
   EXPECT_TRUE(!Err);
   llvm::consumeError(std::move(Err));
 
   EXPECT_TRUE(applyAllReplacements(Replaces, Context.Rewrite));
   EXPECT_EQ("line1\nreplaced\nline3\nline4", Context.getRewrittenText(ID));
 }
 
 TEST_F(ReplacementTest, FailOrderDependentReplacements) {
-  FileID ID = Context.createInMemoryFile("input.cpp",
-                                         "line1\nline2\nline3\nline4");
+  FileID ID =
+      Context.createInMemoryFile("input.cpp", "line1\nline2\nline3\nline4");
   auto Replaces = toReplacements({Replacement(
       Context.Sources, Context.getLocation(ID, 2, 1), 5, "other")});
 
   Replacement ConflictReplacement(Context.Sources,
                                   Context.getLocation(ID, 2, 1), 5, "rehto");
   auto Err = Replaces.add(ConflictReplacement);
   EXPECT_TRUE(checkReplacementError(std::move(Err),
                                     replacement_error::overlap_conflict,
TEST(ShiftedCodePositionTest, NoReplacementText) {
   EXPECT_EQ(0u, Replaces.getShiftedCodePosition(0));
   EXPECT_EQ(0u, Replaces.getShiftedCodePosition(39));
   EXPECT_EQ(3u, Replaces.getShiftedCodePosition(45));
   EXPECT_EQ(0u, Replaces.getShiftedCodePosition(42));
 }
 
 class FlushRewrittenFilesTest : public ::testing::Test {
 public:
-   FlushRewrittenFilesTest() {}
 
-   ~FlushRewrittenFilesTest() override {
     for (llvm::StringMap<std::string>::iterator I = TemporaryFiles.begin(),
                                                 E = TemporaryFiles.end();
          I != E; ++I) {
       llvm::StringRef Name = I->second;
       std::error_code EC = llvm::sys::fs::remove(Name);
       (void)EC;
       assert(!EC);
     }
Replacements Replaces = toReplacements({Replacement(
       Context.Sources, Context.getLocation(ID, 2, 1), 5, "replaced")});
   EXPECT_TRUE(applyAllReplacements(Replaces, Context.Rewrite));
   EXPECT_FALSE(Context.Rewrite.overwriteChangedFiles());
   EXPECT_EQ("line1\nreplaced\nline3\nline4",
             getFileContentFromDisk("input.cpp"));
 }
 
 namespace {
-template <typename T>
-class TestVisitor : public clang::RecursiveASTVisitor<T> {
+template <typename T> class TestVisitor : public clang::RecursiveASTVisitor<T> {
 public:
   bool runOver(StringRef Code) {
     return runToolOnCode(std::make_unique<TestAction>(this), Code);
   }
 
 protected:
   clang::SourceManager *SM;
   clang::ASTContext *Context;
public:
     }
 
   private:
     TestVisitor *Visitor;
   };
 };
 } // end namespace
 
-void expectReplacementAt(const Replacement &Replace,
-                         StringRef File, unsigned Offset, unsigned Length) {
+void expectReplacementAt(const Replacement &Replace, StringRef File,
+                         unsigned Offset, unsigned Length) {
   ASSERT_TRUE(Replace.isApplicable());
   EXPECT_EQ(File, Replace.getFilePath());
   EXPECT_EQ(Offset, Replace.getOffset());
   EXPECT_EQ(Length, Replace.getLength());
 }
 
 class ClassDeclXVisitor : public TestVisitor<ClassDeclXVisitor> {
 public:
TEST(Replacement, FunctionCall) {
   CallToFVisitor CallToF;
   EXPECT_TRUE(CallToF.runOver("void F(); void G() { F(); }"));
   expectReplacementAt(CallToF.Replace, "input.cc", 21, 3);
 }
 
 TEST(Replacement, TemplatedFunctionCall) {
   CallToFVisitor CallToF;
   EXPECT_TRUE(CallToF.runOver(
-        "template <typename T> void F(); void G() { F<int>(); }"));
   expectReplacementAt(CallToF.Replace, "input.cc", 43, 8);
 }
 
 class NestedNameSpecifierAVisitor
     : public TestVisitor<NestedNameSpecifierAVisitor> {
 public:
   bool TraverseNestedNameSpecifierLoc(NestedNameSpecifierLoc NNSLoc) {
     if (NNSLoc.getNestedNameSpecifier()) {
-      if (const NamespaceDecl* NS = NNSLoc.getNestedNameSpecifier()->getAsNamespace()) {
+      if (const NamespaceDecl *NS =
+              NNSLoc.getNestedNameSpecifier()->getAsNamespace()) {
         if (NS->getName() == "a") {
           Replace = Replacement(*SM, &NNSLoc, "", Context->getLangOpts());
         }
       }
     }
-    return TestVisitor<NestedNameSpecifierAVisitor>::TraverseNestedNameSpecifierLoc(
-        NNSLoc);
+    return TestVisitor<
+        NestedNameSpecifierAVisitor>::TraverseNestedNameSpecifierLoc(NNSLoc);
   }
   Replacement Replace;
 };
 
 TEST(Replacement, ColonColon) {
   NestedNameSpecifierAVisitor VisitNNSA;
   EXPECT_TRUE(VisitNNSA.runOver("namespace a { void f() { ::a::f(); } }"));
   expectReplacementAt(VisitNNSA.Replace, "input.cc", 25, 5);
TEST(Range, AjacentReplacements) {
   std::vector<Range> Ranges = {Range(0, 0), Range(15, 5)};
   Replacements Replaces = toReplacements(
       {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)};
+  std::vector<Range> Ranges = {Range(8, 0), Range(5, 2), Range(9, 0),
+                               Range(0, 1)};
   Replacements Replaces = toReplacements({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));
 }
 

 #endif
   FileToReplaces[Path1] = Replacements();
   FileToReplaces[Path2] = Replacements();
   FileToReplaces = groupReplacementsByFile(FileMgr, FileToReplaces);
   EXPECT_TRUE(FileToReplaces.empty());
 }
 
 class AtomicChangeTest : public ::testing::Test {
-  protected:
-    void SetUp() override {
-      DefaultFileID = Context.createInMemoryFile("input.cpp", DefaultCode);
-      DefaultLoc = Context.Sources.getLocForStartOfFile(DefaultFileID)
-                       .getLocWithOffset(20);
-      assert(DefaultLoc.isValid() && "Default location must be valid.");
-    }
 
-    RewriterTestContext Context;
-    std::string DefaultCode = std::string(100, 'a');
-    unsigned DefaultOffset = 20;
-    SourceLocation DefaultLoc;
-    FileID DefaultFileID;
 };
 
 TEST_F(AtomicChangeTest, AtomicChangeToYAML) {
   AtomicChange Change(Context.Sources, DefaultLoc);
   llvm::Error Err =
       Change.insert(Context.Sources, DefaultLoc, "aa", /*InsertAfter=*/false);
   ASSERT_TRUE(!Err);
   Err = Change.insert(Context.Sources, DefaultLoc.getLocWithOffset(10), "bb",
                       /*InsertAfter=*/false);
   ASSERT_TRUE(!Err);
   Change.addHeader("a.h");
   Change.removeHeader("b.h");
   std::string YAMLString = Change.toYAMLString();
 
   // NOTE: If this test starts to fail for no obvious reason, check whitespace.
   ASSERT_STREQ("---\n"
                "Key:             'input.cpp:20'\n"
std::string YamlContent = "---\n"
                             "    ReplacementText: aa\n"
                             "  - FilePath:        input.cpp\n"
                             "    Offset:          30\n"
                             "    Length:          0\n"
                             "    ReplacementText: bb\n"
                             "...\n";
   AtomicChange ExpectedChange(Context.Sources, DefaultLoc);
   llvm::Error Err = ExpectedChange.insert(Context.Sources, DefaultLoc, "aa",
                                           /*InsertAfter=*/false);
   ASSERT_TRUE(!Err);
   Err = ExpectedChange.insert(Context.Sources, DefaultLoc.getLocWithOffset(10),
                               "bb", /*InsertAfter=*/false);
   ASSERT_TRUE(!Err);
 
   ExpectedChange.addHeader("a.h");
   ExpectedChange.removeHeader("b.h");
   ExpectedChange.setError("ok");
 
   AtomicChange ActualChange = AtomicChange::convertFromYAML(YamlContent);
   EXPECT_EQ(ExpectedChange.getKey(), ActualChange.getKey());
TEST_F(AtomicChangeTest, Replace) {
 
   // Add a new replacement that conflicts with the existing one.
   Err = Change.replace(Context.Sources, DefaultLoc, 3, "ab");
   EXPECT_TRUE((bool)Err);
   llvm::consumeError(std::move(Err));
   EXPECT_EQ(Change.getReplacements().size(), 1u);
 }
 
+TEST_F(AtomicChangeTest, ReplaceReportConflict) {
+  AtomicChange Change(Context.Sources, DefaultLoc);
+  llvm::Error Err = Change.replace(Context.Sources, DefaultLoc, 2, "bb");
+  ASSERT_TRUE(!Err);
+  EXPECT_EQ(Change.getReplacements().size(), 1u);
+  EXPECT_EQ(*Change.getReplacements().begin(),
+            Replacement(Context.Sources, DefaultLoc, 2, "bb"));
+
+  // Add a new replacement that conflicts with the existing one.
+  Err = Change.replace(Context.Sources, DefaultLoc, 2, "cc");
+  EXPECT_TRUE((bool)Err);
+  std::string ConflictMessage;
+  llvm::consumeError(
+      llvm::handleErrors(std::move(Err), [&](const ReplacementError &RE) {
+        llvm::raw_string_ostream OS(ConflictMessage);
+        RE.reportConflict(OS, Context.Sources);
+      }));
+  llvm::errs() << ConflictMessage;
+  EXPECT_STREQ("input.cpp:1:21-1:23\n"
+               "<<<<<<< Existing replacement\n"
+               "aaaaaaaaaaaaaaaaaaaabbaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+               "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+               "=======\n"
+               "aaaaaaaaaaaaaaaaaaaaccaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+               "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+               ">>>>>>> New replacement\n",
+               ConflictMessage.c_str());
+}
+
 TEST_F(AtomicChangeTest, ReplaceWithRange) {
   AtomicChange Change(Context.Sources, DefaultLoc);
   SourceLocation End = DefaultLoc.getLocWithOffset(20);
   llvm::Error Err = Change.replace(
       Context.Sources, CharSourceRange::getCharRange(DefaultLoc, End), "aa");
   ASSERT_TRUE(!Err);
   EXPECT_EQ(Change.getReplacements().size(), 1u);
   EXPECT_EQ(*Change.getReplacements().begin(),

 TEST_F(AtomicChangeTest, InsertBeforeWithInvalidLocation) {
   AtomicChange Change(Context.Sources, DefaultLoc);
   llvm::Error Err =
       Change.insert(Context.Sources, DefaultLoc, "a", /*InsertAfter=*/false);
   ASSERT_TRUE(!Err);
 
   // Invalid location.
   Err = Change.insert(Context.Sources, SourceLocation(), "a",
                       /*InsertAfter=*/false);
   ASSERT_TRUE((bool)Err);
   EXPECT_TRUE(checkReplacementError(
       std::move(Err), replacement_error::wrong_file_path,
       Replacement(Context.Sources, DefaultLoc, 0, "a"),
       Replacement(Context.Sources, SourceLocation(), 0, "a")));
 }
 
 TEST_F(AtomicChangeTest, InsertBeforeToWrongFile) {