unittests/Tooling/RefactoringTest.cpp

   1 //===- unittest/Tooling/RefactoringTest.cpp - Refactoring unit tests ------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "ReplacementTest.h"
  11 #include "RewriterTestContext.h"
  12 #include "clang/AST/ASTConsumer.h"
  13 #include "clang/AST/ASTContext.h"
  14 #include "clang/AST/DeclCXX.h"
  15 #include "clang/AST/DeclGroup.h"
  16 #include "clang/AST/RecursiveASTVisitor.h"
  17 #include "clang/Basic/Diagnostic.h"
  18 #include "clang/Basic/DiagnosticOptions.h"
  19 #include "clang/Basic/FileManager.h"
  20 #include "clang/Basic/LangOptions.h"
  21 #include "clang/Basic/SourceManager.h"
  22 #include "clang/Basic/VirtualFileSystem.h"
  23 #include "clang/Format/Format.h"
  24 #include "clang/Frontend/CompilerInstance.h"
  25 #include "clang/Frontend/FrontendAction.h"
  26 #include "clang/Frontend/TextDiagnosticPrinter.h"
  27 #include "clang/Rewrite/Core/Rewriter.h"
  28 #include "clang/Tooling/Refactoring.h"
  29 #include "clang/Tooling/Refactoring/AtomicChange.h"
  30 #include "clang/Tooling/Tooling.h"
  31 #include "llvm/ADT/SmallString.h"
  32 #include "gtest/gtest.h"
  33
  34 namespace clang {
  35 namespace tooling {
  36
  37 TEST_F(ReplacementTest, CanDeleteAllText) {
  38   FileID ID = Context.createInMemoryFile("input.cpp", "text");
  39   SourceLocation Location = Context.getLocation(ID, 1, 1);
  40   Replacement Replace(createReplacement(Location, 4, ""));
  41   EXPECT_TRUE(Replace.apply(Context.Rewrite));
  42   EXPECT_EQ("", Context.getRewrittenText(ID));
  43 }
  44
  45 TEST_F(ReplacementTest, CanDeleteAllTextInTextWithNewlines) {
  46   FileID ID = Context.createInMemoryFile("input.cpp", "line1\nline2\nline3");
  47   SourceLocation Location = Context.getLocation(ID, 1, 1);
  48   Replacement Replace(createReplacement(Location, 17, ""));
  49   EXPECT_TRUE(Replace.apply(Context.Rewrite));
  50   EXPECT_EQ("", Context.getRewrittenText(ID));
  51 }
  52
  53 TEST_F(ReplacementTest, CanAddText) {
  54   FileID ID = Context.createInMemoryFile("input.cpp", "");
  55   SourceLocation Location = Context.getLocation(ID, 1, 1);
  56   Replacement Replace(createReplacement(Location, 0, "result"));
  57   EXPECT_TRUE(Replace.apply(Context.Rewrite));
  58   EXPECT_EQ("result", Context.getRewrittenText(ID));
  59 }
  60
  61 TEST_F(ReplacementTest, CanReplaceTextAtPosition) {
  62   FileID ID = Context.createInMemoryFile("input.cpp",
  63                                          "line1\nline2\nline3\nline4");
  64   SourceLocation Location = Context.getLocation(ID, 2, 3);
  65   Replacement Replace(createReplacement(Location, 12, "x"));
  66   EXPECT_TRUE(Replace.apply(Context.Rewrite));
  67   EXPECT_EQ("line1\nlixne4", Context.getRewrittenText(ID));
  68 }
  69
  70 TEST_F(ReplacementTest, CanReplaceTextAtPositionMultipleTimes) {
  71   FileID ID = Context.createInMemoryFile("input.cpp",
  72                                          "line1\nline2\nline3\nline4");
  73   SourceLocation Location1 = Context.getLocation(ID, 2, 3);
  74   Replacement Replace1(createReplacement(Location1, 12, "x\ny\n"));
  75   EXPECT_TRUE(Replace1.apply(Context.Rewrite));
  76   EXPECT_EQ("line1\nlix\ny\nne4", Context.getRewrittenText(ID));
  77
  78   // Since the original source has not been modified, the (4, 4) points to the
  79   // 'e' in the original content.
  80   SourceLocation Location2 = Context.getLocation(ID, 4, 4);
  81   Replacement Replace2(createReplacement(Location2, 1, "f"));
  82   EXPECT_TRUE(Replace2.apply(Context.Rewrite));
  83   EXPECT_EQ("line1\nlix\ny\nnf4", Context.getRewrittenText(ID));
  84 }
  85
  86 TEST_F(ReplacementTest, ApplyFailsForNonExistentLocation) {
  87   Replacement Replace("nonexistent-file.cpp", 0, 1, "");
  88   EXPECT_FALSE(Replace.apply(Context.Rewrite));
  89 }
  90
  91 TEST_F(ReplacementTest, CanRetrivePath) {
  92   Replacement Replace("/path/to/file.cpp", 0, 1, "");
  93   EXPECT_EQ("/path/to/file.cpp", Replace.getFilePath());
  94 }
  95
  96 TEST_F(ReplacementTest, ReturnsInvalidPath) {
  97   Replacement Replace1(Context.Sources, SourceLocation(), 0, "");
  98   EXPECT_TRUE(Replace1.getFilePath().empty());
  99
 100   Replacement Replace2;
 101   EXPECT_TRUE(Replace2.getFilePath().empty());
 102 }
 103
 104 // Checks that an llvm::Error instance contains a ReplacementError with expected
 105 // error code, expected new replacement, and expected existing replacement.
 106 static bool checkReplacementError(llvm::Error &&Error,
 107                                   replacement_error ExpectedErr,
 108                                   llvm::Optional<Replacement> ExpectedExisting,
 109                                   llvm::Optional<Replacement> ExpectedNew) {
 110   if (!Error) {
 111     llvm::errs() << "Error is a success.";
 112     return false;
 113   }
 114   std::string ErrorMessage;
 115   llvm::raw_string_ostream OS(ErrorMessage);
 116   llvm::handleAllErrors(std::move(Error), [&](const ReplacementError &RE) {
 117     llvm::errs() << "Handling error...\n";
 118     if (ExpectedErr != RE.get())
 119       OS << "Unexpected error code: " << int(RE.get()) << "\n";
 120     if (ExpectedExisting != RE.getExistingReplacement()) {
 121       OS << "Expected Existing != Actual Existing.\n";
 122       if (ExpectedExisting.hasValue())
 123         OS << "Expected existing replacement: " << ExpectedExisting->toString()
 124            << "\n";
 125       if (RE.getExistingReplacement().hasValue())
 126         OS << "Actual existing replacement: "
 127            << RE.getExistingReplacement()->toString() << "\n";
 128     }
 129     if (ExpectedNew != RE.getNewReplacement()) {
 130       OS << "Expected New != Actual New.\n";
 131       if (ExpectedNew.hasValue())
 132         OS << "Expected new replacement: " << ExpectedNew->toString() << "\n";
 133       if (RE.getNewReplacement().hasValue())
 134         OS << "Actual new replacement: " << RE.getNewReplacement()->toString()
 135            << "\n";
 136     }
 137   });
 138   OS.flush();
 139   if (ErrorMessage.empty()) return true;
 140   llvm::errs() << ErrorMessage;
 141   return false;
 142 }
 143
 144 TEST_F(ReplacementTest, FailAddReplacements) {
 145   Replacements Replaces;
 146   Replacement Deletion("x.cc", 0, 10, "3");
 147   auto Err = Replaces.add(Deletion);
 148   EXPECT_TRUE(!Err);
 149   llvm::consumeError(std::move(Err));
 150
 151   Replacement OverlappingReplacement("x.cc", 0, 2, "a");
 152   Err = Replaces.add(OverlappingReplacement);
 153   EXPECT_TRUE(checkReplacementError(std::move(Err),
 154                                     replacement_error::overlap_conflict,
 155                                     Deletion, OverlappingReplacement));
 156
 157   Replacement ContainedReplacement("x.cc", 2, 2, "a");
 158   Err = Replaces.add(Replacement(ContainedReplacement));
 159   EXPECT_TRUE(checkReplacementError(std::move(Err),
 160                                     replacement_error::overlap_conflict,
 161                                     Deletion, ContainedReplacement));
 162
 163   Replacement WrongPathReplacement("y.cc", 20, 2, "");
 164   Err = Replaces.add(WrongPathReplacement);
 165   EXPECT_TRUE(checkReplacementError(std::move(Err),
 166                                     replacement_error::wrong_file_path,
 167                                     Deletion, WrongPathReplacement));
 168
 169   EXPECT_EQ(1u, Replaces.size());
 170   EXPECT_EQ(Deletion, *Replaces.begin());
 171 }
 172
 173 TEST_F(ReplacementTest, DeletionInReplacements) {
 174   Replacements Replaces;
 175   Replacement R("x.cc", 0, 10, "3");
 176   auto Err = Replaces.add(R);
 177   EXPECT_TRUE(!Err);
 178   llvm::consumeError(std::move(Err));
 179   Err = Replaces.add(Replacement("x.cc", 0, 2, ""));
 180   EXPECT_TRUE(!Err);
 181   llvm::consumeError(std::move(Err));
 182   Err = Replaces.add(Replacement("x.cc", 2, 2, ""));
 183   EXPECT_TRUE(!Err);
 184   llvm::consumeError(std::move(Err));
 185   EXPECT_EQ(1u, Replaces.size());
 186   EXPECT_EQ(R, *Replaces.begin());
 187 }
 188
 189 TEST_F(ReplacementTest, OverlappingReplacements) {
 190   Replacements Replaces;
 191   auto Err = Replaces.add(Replacement("x.cc", 0, 3, "345"));
 192   EXPECT_TRUE(!Err);
 193   llvm::consumeError(std::move(Err));
 194   Err = Replaces.add(Replacement("x.cc", 2, 3, "543"));
 195   EXPECT_TRUE(!Err);
 196   llvm::consumeError(std::move(Err));
 197
 198   EXPECT_EQ(1u, Replaces.size());
 199   EXPECT_EQ(Replacement("x.cc", 0, 5, "34543"), *Replaces.begin());
 200
 201   Err = Replaces.add(Replacement("x.cc", 2, 1, "5"));
 202   EXPECT_TRUE(!Err);
 203   llvm::consumeError(std::move(Err));
 204   EXPECT_EQ(1u, Replaces.size());
 205   EXPECT_EQ(Replacement("x.cc", 0, 5, "34543"), *Replaces.begin());
 206 }
 207
 208 TEST_F(ReplacementTest, AddAdjacentInsertionAndReplacement) {
 209   Replacements Replaces;
 210   // Test adding an insertion at the offset of an existing replacement.
 211   auto Err = Replaces.add(Replacement("x.cc", 10, 3, "replace"));
 212   EXPECT_TRUE(!Err);
 213   llvm::consumeError(std::move(Err));
 214   Err = Replaces.add(Replacement("x.cc", 10, 0, "insert"));
 215   EXPECT_TRUE(!Err);
 216   llvm::consumeError(std::move(Err));
 217   EXPECT_EQ(Replaces.size(), 2u);
 218
 219   Replaces.clear();
 220   // Test overlap with an existing insertion.
 221   Err = Replaces.add(Replacement("x.cc", 10, 0, "insert"));
 222   EXPECT_TRUE(!Err);
 223   llvm::consumeError(std::move(Err));
 224   Err = Replaces.add(Replacement("x.cc", 10, 3, "replace"));
 225   EXPECT_TRUE(!Err);
 226   llvm::consumeError(std::move(Err));
 227   EXPECT_EQ(Replaces.size(), 2u);
 228 }
 229
 230 TEST_F(ReplacementTest, MergeNewDeletions) {
 231   Replacements Replaces;
 232   Replacement ContainingReplacement("x.cc", 0, 10, "");
 233   auto Err = Replaces.add(ContainingReplacement);
 234   EXPECT_TRUE(!Err);
 235   llvm::consumeError(std::move(Err));
 236
 237   Err = Replaces.add(Replacement("x.cc", 5, 3, ""));
 238   EXPECT_TRUE(!Err);
 239   llvm::consumeError(std::move(Err));
 240
 241   Err = Replaces.add(Replacement("x.cc", 0, 10, ""));
 242   EXPECT_TRUE(!Err);
 243   llvm::consumeError(std::move(Err));
 244
 245   Err = Replaces.add(Replacement("x.cc", 5, 5, ""));
 246   EXPECT_TRUE(!Err);
 247   llvm::consumeError(std::move(Err));
 248
 249   EXPECT_EQ(1u, Replaces.size());
 250   EXPECT_EQ(*Replaces.begin(), ContainingReplacement);
 251 }
 252
 253 TEST_F(ReplacementTest, MergeOverlappingButNotAdjacentReplacement) {
 254   Replacements Replaces;
 255   auto Err = Replaces.add(Replacement("x.cc", 0, 2, ""));
 256   EXPECT_TRUE(!Err);
 257   llvm::consumeError(std::move(Err));
 258
 259   Err = Replaces.add(Replacement("x.cc", 5, 5, ""));
 260   EXPECT_TRUE(!Err);
 261   llvm::consumeError(std::move(Err));
 262
 263   Replacement After = Replacement("x.cc", 10, 5, "");
 264   Err = Replaces.add(After);
 265   EXPECT_TRUE(!Err);
 266   llvm::consumeError(std::move(Err));
 267
 268   Replacement ContainingReplacement("x.cc", 0, 10, "");
 269   Err = Replaces.add(ContainingReplacement);
 270   EXPECT_TRUE(!Err);
 271   llvm::consumeError(std::move(Err));
 272
 273   EXPECT_EQ(2u, Replaces.size());
 274   EXPECT_EQ(*Replaces.begin(), ContainingReplacement);
 275   EXPECT_EQ(*(++Replaces.begin()), After);
 276 }
 277
 278 TEST_F(ReplacementTest, InsertionBeforeMergedDeletions) {
 279   Replacements Replaces;
 280
 281   Replacement Insertion("x.cc", 0, 0, "123");
 282   auto Err = Replaces.add(Insertion);
 283   EXPECT_TRUE(!Err);
 284   llvm::consumeError(std::move(Err));
 285
 286   Err = Replaces.add(Replacement("x.cc", 5, 5, ""));
 287   EXPECT_TRUE(!Err);
 288   llvm::consumeError(std::move(Err));
 289
 290   Replacement Deletion("x.cc", 0, 10, "");
 291   Err = Replaces.add(Deletion);
 292   EXPECT_TRUE(!Err);
 293   llvm::consumeError(std::move(Err));
 294
 295   EXPECT_EQ(2u, Replaces.size());
 296   EXPECT_EQ(*Replaces.begin(), Insertion);
 297   EXPECT_EQ(*(++Replaces.begin()), Deletion);
 298 }
 299
 300 TEST_F(ReplacementTest, MergeOverlappingDeletions) {
 301   Replacements Replaces;
 302   auto Err = Replaces.add(Replacement("x.cc", 0, 2, ""));
 303   EXPECT_TRUE(!Err);
 304   llvm::consumeError(std::move(Err));
 305
 306   Err = Replaces.add(Replacement("x.cc", 0, 5, ""));
 307   EXPECT_TRUE(!Err);
 308   llvm::consumeError(std::move(Err));
 309
 310   EXPECT_EQ(1u, Replaces.size());
 311   EXPECT_EQ(Replacement("x.cc", 0, 5, ""), *Replaces.begin());
 312
 313   Err = Replaces.add(Replacement("x.cc", 1, 5, ""));
 314   EXPECT_TRUE(!Err);
 315   llvm::consumeError(std::move(Err));
 316   EXPECT_EQ(1u, Replaces.size());
 317   EXPECT_EQ(Replacement("x.cc", 0, 6, ""), *Replaces.begin());
 318 }
 319
 320 TEST_F(ReplacementTest, FailedMergeExistingDeletions) {
 321   Replacements Replaces;
 322   Replacement First("x.cc", 0, 2, "");
 323   auto Err = Replaces.add(First);
 324   EXPECT_TRUE(!Err);
 325   llvm::consumeError(std::move(Err));
 326
 327   Replacement Second("x.cc", 5, 5, "");
 328   Err = Replaces.add(Second);
 329   EXPECT_TRUE(!Err);
 330   llvm::consumeError(std::move(Err));
 331
 332   Err = Replaces.add(Replacement("x.cc", 1, 10, ""));
 333   EXPECT_TRUE(!Err);
 334   llvm::consumeError(std::move(Err));
 335
 336   EXPECT_EQ(1u, Replaces.size());
 337   EXPECT_EQ(Replacement("x.cc", 0, 11, ""), *Replaces.begin());
 338 }
 339
 340 TEST_F(ReplacementTest, FailAddRegression) {
 341   Replacements Replaces;
 342   // Create two replacements, where the second one is an insertion of the empty
 343   // string exactly at the end of the first one.
 344   auto Err = Replaces.add(Replacement("x.cc", 0, 10, "1"));
 345   EXPECT_TRUE(!Err);
 346   llvm::consumeError(std::move(Err));
 347   Err = Replaces.add(Replacement("x.cc", 10, 0, ""));
 348   EXPECT_TRUE(!Err);
 349   llvm::consumeError(std::move(Err));
 350
 351   // Make sure we find the overlap with the first entry when inserting a
 352   // replacement that ends exactly at the seam of the existing replacements.
 353   Replacement OverlappingReplacement("x.cc", 5, 5, "fail");
 354   Err = Replaces.add(OverlappingReplacement);
 355   EXPECT_TRUE(checkReplacementError(std::move(Err),
 356                                     replacement_error::overlap_conflict,
 357                                     *Replaces.begin(), OverlappingReplacement));
 358
 359   Err = Replaces.add(Replacement("x.cc", 10, 0, ""));
 360   EXPECT_TRUE(!Err);
 361   llvm::consumeError(std::move(Err));
 362 }
 363
 364 TEST_F(ReplacementTest, InsertAtOffsetOfReplacement) {
 365   Replacements Replaces;
 366   auto Err = Replaces.add(Replacement("x.cc", 10, 2, ""));
 367   EXPECT_TRUE(!Err);
 368   llvm::consumeError(std::move(Err));
 369   Err = Replaces.add(Replacement("x.cc", 10, 0, ""));
 370   EXPECT_TRUE(!Err);
 371   llvm::consumeError(std::move(Err));
 372   EXPECT_EQ(Replaces.size(), 2u);
 373
 374   Replaces.clear();
 375   Err = Replaces.add(Replacement("x.cc", 10, 0, ""));
 376   EXPECT_TRUE(!Err);
 377   llvm::consumeError(std::move(Err));
 378   Err = Replaces.add(Replacement("x.cc", 10, 2, ""));
 379   EXPECT_TRUE(!Err);
 380   llvm::consumeError(std::move(Err));
 381   EXPECT_EQ(Replaces.size(), 2u);
 382 }
 383
 384 TEST_F(ReplacementTest, AddInsertAtOtherInsertWhenOderIndependent) {
 385   Replacements Replaces;
 386   auto Err = Replaces.add(Replacement("x.cc", 10, 0, "a"));
 387   EXPECT_TRUE(!Err);
 388   llvm::consumeError(std::move(Err));
 389   Replacement ConflictInsertion("x.cc", 10, 0, "b");
 390   Err = Replaces.add(ConflictInsertion);
 391   EXPECT_TRUE(checkReplacementError(std::move(Err),
 392                                     replacement_error::insert_conflict,
 393                                     *Replaces.begin(), ConflictInsertion));
 394
 395   Replaces.clear();
 396   Err = Replaces.add(Replacement("x.cc", 10, 0, "a"));
 397   EXPECT_TRUE(!Err);
 398   llvm::consumeError(std::move(Err));
 399   Err = Replaces.add(Replacement("x.cc", 10, 0, "aa"));
 400   EXPECT_TRUE(!Err);
 401   llvm::consumeError(std::move(Err));
 402   EXPECT_EQ(1u, Replaces.size());
 403   EXPECT_EQ(Replacement("x.cc", 10, 0, "aaa"), *Replaces.begin());
 404
 405   Replaces.clear();
 406   Err = Replaces.add(Replacement("x.cc", 10, 0, ""));
 407   EXPECT_TRUE(!Err);
 408   llvm::consumeError(std::move(Err));
 409   Err = Replaces.add(Replacement("x.cc", 10, 3, ""));
 410   EXPECT_TRUE(!Err);
 411   llvm::consumeError(std::move(Err));
 412   Err = Replaces.add(Replacement("x.cc", 10, 0, ""));
 413   EXPECT_TRUE(!Err);
 414   llvm::consumeError(std::move(Err));
 415   EXPECT_EQ(2u, Replaces.size());
 416   EXPECT_EQ(Replacement("x.cc", 10, 0, ""), *Replaces.begin());
 417   EXPECT_EQ(Replacement("x.cc", 10, 3, ""), *std::next(Replaces.begin()));
 418 }
 419
 420 TEST_F(ReplacementTest, InsertBetweenAdjacentReplacements) {
 421   Replacements Replaces;
 422   auto Err = Replaces.add(Replacement("x.cc", 10, 5, "a"));
 423   EXPECT_TRUE(!Err);
 424   llvm::consumeError(std::move(Err));
 425   Err = Replaces.add(Replacement("x.cc", 8, 2, "a"));
 426   EXPECT_TRUE(!Err);
 427   llvm::consumeError(std::move(Err));
 428   Err = Replaces.add(Replacement("x.cc", 10, 0, "b"));
 429   EXPECT_TRUE(!Err);
 430   llvm::consumeError(std::move(Err));
 431 }
 432
 433 TEST_F(ReplacementTest, CanApplyReplacements) {
 434   FileID ID = Context.createInMemoryFile("input.cpp",
 435                                          "line1\nline2\nline3\nline4");
 436   Replacements Replaces =
 437       toReplacements({Replacement(Context.Sources,
 438                                   Context.getLocation(ID, 2, 1), 5, "replaced"),
 439                       Replacement(Context.Sources,
 440                                   Context.getLocation(ID, 3, 1), 5, "other")});
 441   EXPECT_TRUE(applyAllReplacements(Replaces, Context.Rewrite));
 442   EXPECT_EQ("line1\nreplaced\nother\nline4", Context.getRewrittenText(ID));
 443 }
 444
 445 // Verifies that replacement/deletion is applied before insertion at the same
 446 // offset.
 447 TEST_F(ReplacementTest, InsertAndDelete) {
 448   FileID ID = Context.createInMemoryFile("input.cpp",
 449                                          "line1\nline2\nline3\nline4");
 450   Replacements Replaces = toReplacements(
 451       {Replacement(Context.Sources, Context.getLocation(ID, 2, 1), 6, ""),
 452        Replacement(Context.Sources, Context.getLocation(ID, 2, 1), 0,
 453                    "other\n")});
 454   EXPECT_TRUE(applyAllReplacements(Replaces, Context.Rewrite));
 455   EXPECT_EQ("line1\nother\nline3\nline4", Context.getRewrittenText(ID));
 456 }
 457
 458 TEST_F(ReplacementTest, AdjacentReplacements) {
 459   FileID ID = Context.createInMemoryFile("input.cpp",
 460                                          "ab");
 461   Replacements Replaces = toReplacements(
 462       {Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 1, "x"),
 463        Replacement(Context.Sources, Context.getLocation(ID, 1, 2), 1, "y")});
 464   EXPECT_TRUE(applyAllReplacements(Replaces, Context.Rewrite));
 465   EXPECT_EQ("xy", Context.getRewrittenText(ID));
 466 }
 467
 468 TEST_F(ReplacementTest, AddDuplicateReplacements) {
 469   FileID ID = Context.createInMemoryFile("input.cpp",
 470                                          "line1\nline2\nline3\nline4");
 471   auto Replaces = toReplacements({Replacement(
 472       Context.Sources, Context.getLocation(ID, 2, 1), 5, "replaced")});
 473
 474   auto Err = Replaces.add(Replacement(
 475       Context.Sources, Context.getLocation(ID, 2, 1), 5, "replaced"));
 476   EXPECT_TRUE(!Err);
 477   llvm::consumeError(std::move(Err));
 478
 479   Err = Replaces.add(Replacement(Context.Sources, Context.getLocation(ID, 2, 1),
 480                                  5, "replaced"));
 481   EXPECT_TRUE(!Err);
 482   llvm::consumeError(std::move(Err));
 483
 484   EXPECT_TRUE(applyAllReplacements(Replaces, Context.Rewrite));
 485   EXPECT_EQ("line1\nreplaced\nline3\nline4", Context.getRewrittenText(ID));
 486 }
 487
 488 TEST_F(ReplacementTest, FailOrderDependentReplacements) {
 489   FileID ID = Context.createInMemoryFile("input.cpp",
 490                                          "line1\nline2\nline3\nline4");
 491   auto Replaces = toReplacements({Replacement(
 492       Context.Sources, Context.getLocation(ID, 2, 1), 5, "other")});
 493
 494   Replacement ConflictReplacement(Context.Sources,
 495                                   Context.getLocation(ID, 2, 1), 5, "rehto");
 496   auto Err = Replaces.add(ConflictReplacement);
 497   EXPECT_TRUE(checkReplacementError(std::move(Err),
 498                                     replacement_error::overlap_conflict,
 499                                     *Replaces.begin(), ConflictReplacement));
 500
 501   EXPECT_TRUE(applyAllReplacements(Replaces, Context.Rewrite));
 502   EXPECT_EQ("line1\nother\nline3\nline4", Context.getRewrittenText(ID));
 503 }
 504
 505 TEST_F(ReplacementTest, InvalidSourceLocationFailsApplyAll) {
 506   Replacements Replaces =
 507       toReplacements({Replacement(Context.Sources, SourceLocation(), 5, "2")});
 508
 509   EXPECT_FALSE(applyAllReplacements(Replaces, Context.Rewrite));
 510 }
 511
 512 TEST_F(ReplacementTest, MultipleFilesReplaceAndFormat) {
 513   // Column limit is 20.
 514   std::string Code1 = "Long *a =\n"
 515                       "    new Long();\n"
 516                       "long x = 1;";
 517   std::string Expected1 = "auto a = new Long();\n"
 518                           "long x =\n"
 519                           "    12345678901;";
 520   std::string Code2 = "int x = 123;\n"
 521                       "int y = 0;";
 522   std::string Expected2 = "int x =\n"
 523                           "    1234567890123;\n"
 524                           "int y = 10;";
 525   StringRef File1 = "format_1.cpp";
 526   StringRef File2 = "format_2.cpp";
 527   FileID ID1 = Context.createInMemoryFile(File1, Code1);
 528   FileID ID2 = Context.createInMemoryFile(File2, Code2);
 529
 530   // Scrambled the order of replacements.
 531   std::map<std::string, Replacements> FileToReplaces;
 532   FileToReplaces[File1] = toReplacements(
 533       {tooling::Replacement(Context.Sources, Context.getLocation(ID1, 1, 1), 6,
 534                             "auto "),
 535        tooling::Replacement(Context.Sources, Context.getLocation(ID1, 3, 10), 1,
 536                             "12345678901")});
 537   FileToReplaces[File2] = toReplacements(
 538       {tooling::Replacement(Context.Sources, Context.getLocation(ID2, 1, 12), 0,
 539                             "4567890123"),
 540        tooling::Replacement(Context.Sources, Context.getLocation(ID2, 2, 9), 1,
 541                             "10")});
 542   EXPECT_TRUE(
 543       formatAndApplyAllReplacements(FileToReplaces, Context.Rewrite,
 544                                     "{BasedOnStyle: LLVM, ColumnLimit: 20}"));
 545   EXPECT_EQ(Expected1, Context.getRewrittenText(ID1));
 546   EXPECT_EQ(Expected2, Context.getRewrittenText(ID2));
 547 }
 548
 549 TEST(ShiftedCodePositionTest, FindsNewCodePosition) {
 550   Replacements Replaces =
 551       toReplacements({Replacement("", 0, 1, ""), Replacement("", 4, 3, " ")});
 552   // Assume ' int   i;' is turned into 'int i;' and cursor is located at '|'.
 553   EXPECT_EQ(0u, Replaces.getShiftedCodePosition(0)); // |int   i;
 554   EXPECT_EQ(0u, Replaces.getShiftedCodePosition(1)); //  |nt   i;
 555   EXPECT_EQ(1u, Replaces.getShiftedCodePosition(2)); //  i|t   i;
 556   EXPECT_EQ(2u, Replaces.getShiftedCodePosition(3)); //  in|   i;
 557   EXPECT_EQ(3u, Replaces.getShiftedCodePosition(4)); //  int|  i;
 558   EXPECT_EQ(3u, Replaces.getShiftedCodePosition(5)); //  int | i;
 559   EXPECT_EQ(3u, Replaces.getShiftedCodePosition(6)); //  int  |i;
 560   EXPECT_EQ(4u, Replaces.getShiftedCodePosition(7)); //  int   |;
 561   EXPECT_EQ(5u, Replaces.getShiftedCodePosition(8)); //  int   i|
 562 }
 563
 564 TEST(ShiftedCodePositionTest, FindsNewCodePositionWithInserts) {
 565   Replacements Replaces = toReplacements({Replacement("", 4, 0, "\"\n\"")});
 566   // Assume '"12345678"' is turned into '"1234"\n"5678"'.
 567   EXPECT_EQ(3u, Replaces.getShiftedCodePosition(3)); // "123|5678"
 568   EXPECT_EQ(7u, Replaces.getShiftedCodePosition(4)); // "1234|678"
 569   EXPECT_EQ(8u, Replaces.getShiftedCodePosition(5)); // "12345|78"
 570 }
 571
 572 TEST(ShiftedCodePositionTest, FindsNewCodePositionInReplacedText) {
 573   // Replace the first four characters with "abcd".
 574   auto Replaces = toReplacements({Replacement("", 0, 4, "abcd")});
 575   for (unsigned i = 0; i < 3; ++i)
 576     EXPECT_EQ(i, Replaces.getShiftedCodePosition(i));
 577 }
 578
 579 TEST(ShiftedCodePositionTest, NoReplacementText) {
 580   Replacements Replaces = toReplacements({Replacement("", 0, 42, "")});
 581   EXPECT_EQ(0u, Replaces.getShiftedCodePosition(0));
 582   EXPECT_EQ(0u, Replaces.getShiftedCodePosition(39));
 583   EXPECT_EQ(3u, Replaces.getShiftedCodePosition(45));
 584   EXPECT_EQ(0u, Replaces.getShiftedCodePosition(42));
 585 }
 586
 587 class FlushRewrittenFilesTest : public ::testing::Test {
 588 public:
 589    FlushRewrittenFilesTest() {}
 590
 591    ~FlushRewrittenFilesTest() override {
 592     for (llvm::StringMap<std::string>::iterator I = TemporaryFiles.begin(),
 593                                                 E = TemporaryFiles.end();
 594          I != E; ++I) {
 595       llvm::StringRef Name = I->second;
 596       std::error_code EC = llvm::sys::fs::remove(Name);
 597       (void)EC;
 598       assert(!EC);
 599     }
 600   }
 601
 602   FileID createFile(llvm::StringRef Name, llvm::StringRef Content) {
 603     SmallString<1024> Path;
 604     int FD;
 605     std::error_code EC = llvm::sys::fs::createTemporaryFile(Name, "", FD, Path);
 606     assert(!EC);
 607     (void)EC;
 608
 609     llvm::raw_fd_ostream OutStream(FD, true);
 610     OutStream << Content;
 611     OutStream.close();
 612     const FileEntry *File = Context.Files.getFile(Path);
 613     assert(File != nullptr);
 614
 615     StringRef Found =
 616         TemporaryFiles.insert(std::make_pair(Name, Path.str())).first->second;
 617     assert(Found == Path);
 618     (void)Found;
 619     return Context.Sources.createFileID(File, SourceLocation(), SrcMgr::C_User);
 620   }
 621
 622   std::string getFileContentFromDisk(llvm::StringRef Name) {
 623     std::string Path = TemporaryFiles.lookup(Name);
 624     assert(!Path.empty());
 625     // We need to read directly from the FileManager without relaying through
 626     // a FileEntry, as otherwise we'd read through an already opened file
 627     // descriptor, which might not see the changes made.
 628     // FIXME: Figure out whether there is a way to get the SourceManger to
 629     // reopen the file.
 630     auto FileBuffer = Context.Files.getBufferForFile(Path);
 631     return (*FileBuffer)->getBuffer();
 632   }
 633
 634   llvm::StringMap<std::string> TemporaryFiles;
 635   RewriterTestContext Context;
 636 };
 637
 638 TEST_F(FlushRewrittenFilesTest, StoresChangesOnDisk) {
 639   FileID ID = createFile("input.cpp", "line1\nline2\nline3\nline4");
 640   Replacements Replaces = toReplacements({Replacement(
 641       Context.Sources, Context.getLocation(ID, 2, 1), 5, "replaced")});
 642   EXPECT_TRUE(applyAllReplacements(Replaces, Context.Rewrite));
 643   EXPECT_FALSE(Context.Rewrite.overwriteChangedFiles());
 644   EXPECT_EQ("line1\nreplaced\nline3\nline4",
 645             getFileContentFromDisk("input.cpp"));
 646 }
 647
 648 namespace {
 649 template <typename T>
 650 class TestVisitor : public clang::RecursiveASTVisitor<T> {
 651 public:
 652   bool runOver(StringRef Code) {
 653     return runToolOnCode(new TestAction(this), Code);
 654   }
 655
 656 protected:
 657   clang::SourceManager *SM;
 658   clang::ASTContext *Context;
 659
 660 private:
 661   class FindConsumer : public clang::ASTConsumer {
 662   public:
 663     FindConsumer(TestVisitor *Visitor) : Visitor(Visitor) {}
 664
 665     void HandleTranslationUnit(clang::ASTContext &Context) override {
 666       Visitor->TraverseDecl(Context.getTranslationUnitDecl());
 667     }
 668
 669   private:
 670     TestVisitor *Visitor;
 671   };
 672
 673   class TestAction : public clang::ASTFrontendAction {
 674   public:
 675     TestAction(TestVisitor *Visitor) : Visitor(Visitor) {}
 676
 677     std::unique_ptr<clang::ASTConsumer>
 678     CreateASTConsumer(clang::CompilerInstance &compiler,
 679                       llvm::StringRef dummy) override {
 680       Visitor->SM = &compiler.getSourceManager();
 681       Visitor->Context = &compiler.getASTContext();
 682       /// TestConsumer will be deleted by the framework calling us.
 683       return llvm::make_unique<FindConsumer>(Visitor);
 684     }
 685
 686   private:
 687     TestVisitor *Visitor;
 688   };
 689 };
 690 } // end namespace
 691
 692 void expectReplacementAt(const Replacement &Replace,
 693                          StringRef File, unsigned Offset, unsigned Length) {
 694   ASSERT_TRUE(Replace.isApplicable());
 695   EXPECT_EQ(File, Replace.getFilePath());
 696   EXPECT_EQ(Offset, Replace.getOffset());
 697   EXPECT_EQ(Length, Replace.getLength());
 698 }
 699
 700 class ClassDeclXVisitor : public TestVisitor<ClassDeclXVisitor> {
 701 public:
 702   bool VisitCXXRecordDecl(CXXRecordDecl *Record) {
 703     if (Record->getName() == "X") {
 704       Replace = Replacement(*SM, Record, "");
 705     }
 706     return true;
 707   }
 708   Replacement Replace;
 709 };
 710
 711 TEST(Replacement, CanBeConstructedFromNode) {
 712   ClassDeclXVisitor ClassDeclX;
 713   EXPECT_TRUE(ClassDeclX.runOver("     class X;"));
 714   expectReplacementAt(ClassDeclX.Replace, "input.cc", 5, 7);
 715 }
 716
 717 TEST(Replacement, ReplacesAtSpellingLocation) {
 718   ClassDeclXVisitor ClassDeclX;
 719   EXPECT_TRUE(ClassDeclX.runOver("#define A(Y) Y\nA(class X);"));
 720   expectReplacementAt(ClassDeclX.Replace, "input.cc", 17, 7);
 721 }
 722
 723 class CallToFVisitor : public TestVisitor<CallToFVisitor> {
 724 public:
 725   bool VisitCallExpr(CallExpr *Call) {
 726     if (Call->getDirectCallee()->getName() == "F") {
 727       Replace = Replacement(*SM, Call, "");
 728     }
 729     return true;
 730   }
 731   Replacement Replace;
 732 };
 733
 734 TEST(Replacement, FunctionCall) {
 735   CallToFVisitor CallToF;
 736   EXPECT_TRUE(CallToF.runOver("void F(); void G() { F(); }"));
 737   expectReplacementAt(CallToF.Replace, "input.cc", 21, 3);
 738 }
 739
 740 TEST(Replacement, TemplatedFunctionCall) {
 741   CallToFVisitor CallToF;
 742   EXPECT_TRUE(CallToF.runOver(
 743         "template <typename T> void F(); void G() { F<int>(); }"));
 744   expectReplacementAt(CallToF.Replace, "input.cc", 43, 8);
 745 }
 746
 747 class NestedNameSpecifierAVisitor
 748     : public TestVisitor<NestedNameSpecifierAVisitor> {
 749 public:
 750   bool TraverseNestedNameSpecifierLoc(NestedNameSpecifierLoc NNSLoc) {
 751     if (NNSLoc.getNestedNameSpecifier()) {
 752       if (const NamespaceDecl* NS = NNSLoc.getNestedNameSpecifier()->getAsNamespace()) {
 753         if (NS->getName() == "a") {
 754           Replace = Replacement(*SM, &NNSLoc, "", Context->getLangOpts());
 755         }
 756       }
 757     }
 758     return TestVisitor<NestedNameSpecifierAVisitor>::TraverseNestedNameSpecifierLoc(
 759         NNSLoc);
 760   }
 761   Replacement Replace;
 762 };
 763
 764 TEST(Replacement, ColonColon) {
 765   NestedNameSpecifierAVisitor VisitNNSA;
 766   EXPECT_TRUE(VisitNNSA.runOver("namespace a { void f() { ::a::f(); } }"));
 767   expectReplacementAt(VisitNNSA.Replace, "input.cc", 25, 5);
 768 }
 769
 770 TEST(Range, overlaps) {
 771   EXPECT_TRUE(Range(10, 10).overlapsWith(Range(0, 11)));
 772   EXPECT_TRUE(Range(0, 11).overlapsWith(Range(10, 10)));
 773   EXPECT_FALSE(Range(10, 10).overlapsWith(Range(0, 10)));
 774   EXPECT_FALSE(Range(0, 10).overlapsWith(Range(10, 10)));
 775   EXPECT_TRUE(Range(0, 10).overlapsWith(Range(2, 6)));
 776   EXPECT_TRUE(Range(2, 6).overlapsWith(Range(0, 10)));
 777 }
 778
 779 TEST(Range, contains) {
 780   EXPECT_TRUE(Range(0, 10).contains(Range(0, 10)));
 781   EXPECT_TRUE(Range(0, 10).contains(Range(2, 6)));
 782   EXPECT_FALSE(Range(2, 6).contains(Range(0, 10)));
 783   EXPECT_FALSE(Range(0, 10).contains(Range(0, 11)));
 784 }
 785
 786 TEST(Range, CalculateRangesOfReplacements) {
 787   // Before: aaaabbbbbbz
 788   // After : bbbbbbzzzzzzoooooooooooooooo
 789   Replacements Replaces = toReplacements(
 790       {Replacement("foo", 0, 4, ""), Replacement("foo", 10, 1, "zzzzzz"),
 791        Replacement("foo", 11, 0, "oooooooooooooooo")});
 792
 793   std::vector<Range> Ranges = Replaces.getAffectedRanges();
 794
 795   EXPECT_EQ(2ul, Ranges.size());
 796   EXPECT_TRUE(Ranges[0].getOffset() == 0);
 797   EXPECT_TRUE(Ranges[0].getLength() == 0);
 798   EXPECT_TRUE(Ranges[1].getOffset() == 6);
 799   EXPECT_TRUE(Ranges[1].getLength() == 22);
 800 }
 801
 802 TEST(Range, CalculateRangesOfInsertionAroundReplacement) {
 803   Replacements Replaces = toReplacements(
 804       {Replacement("foo", 0, 2, ""), Replacement("foo", 0, 0, "ba")});
 805
 806   std::vector<Range> Ranges = Replaces.getAffectedRanges();
 807
 808   EXPECT_EQ(1ul, Ranges.size());
 809   EXPECT_EQ(0u, Ranges[0].getOffset());
 810   EXPECT_EQ(2u, Ranges[0].getLength());
 811 }
 812
 813 TEST(Range, RangesAfterEmptyReplacements) {
 814   std::vector<Range> Ranges = {Range(5, 6), Range(10, 5)};
 815   Replacements Replaces;
 816   std::vector<Range> Expected = {Range(5, 10)};
 817   EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
 818 }
 819
 820 TEST(Range, RangesAfterReplacements) {
 821   std::vector<Range> Ranges = {Range(5, 2), Range(10, 5)};
 822   Replacements Replaces = toReplacements({Replacement("foo", 0, 2, "1234")});
 823   std::vector<Range> Expected = {Range(0, 4), Range(7, 2), Range(12, 5)};
 824   EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
 825 }
 826
 827 TEST(Range, RangesBeforeReplacements) {
 828   std::vector<Range> Ranges = {Range(5, 2), Range(10, 5)};
 829   Replacements Replaces = toReplacements({Replacement("foo", 20, 2, "1234")});
 830   std::vector<Range> Expected = {Range(5, 2), Range(10, 5), Range(20, 4)};
 831   EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
 832 }
 833
 834 TEST(Range, NotAffectedByReplacements) {
 835   std::vector<Range> Ranges = {Range(0, 2), Range(5, 2), Range(10, 5)};
 836   Replacements Replaces = toReplacements({Replacement("foo", 3, 2, "12"),
 837                                           Replacement("foo", 12, 2, "12"),
 838                                           Replacement("foo", 20, 5, "")});
 839   std::vector<Range> Expected = {Range(0, 2), Range(3, 4), Range(10, 5),
 840                                  Range(20, 0)};
 841   EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
 842 }
 843
 844 TEST(Range, RangesWithNonOverlappingReplacements) {
 845   std::vector<Range> Ranges = {Range(0, 2), Range(5, 2), Range(10, 5)};
 846   Replacements Replaces = toReplacements({Replacement("foo", 3, 1, ""),
 847                                           Replacement("foo", 6, 1, "123"),
 848                                           Replacement("foo", 20, 2, "12345")});
 849   std::vector<Range> Expected = {Range(0, 2), Range(3, 0), Range(4, 4),
 850                                  Range(11, 5), Range(21, 5)};
 851   EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
 852 }
 853
 854 TEST(Range, RangesWithOverlappingReplacements) {
 855   std::vector<Range> Ranges = {Range(0, 2), Range(5, 2), Range(15, 5),
 856                                Range(30, 5)};
 857   Replacements Replaces = toReplacements(
 858       {Replacement("foo", 1, 3, ""), Replacement("foo", 6, 1, "123"),
 859        Replacement("foo", 13, 3, "1"), Replacement("foo", 25, 15, "")});
 860   std::vector<Range> Expected = {Range(0, 1), Range(2, 4), Range(12, 5),
 861                                  Range(22, 0)};
 862   EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
 863 }
 864
 865 TEST(Range, MergeIntoOneRange) {
 866   std::vector<Range> Ranges = {Range(0, 2), Range(5, 2), Range(15, 5)};
 867   Replacements Replaces =
 868       toReplacements({Replacement("foo", 1, 15, "1234567890")});
 869   std::vector<Range> Expected = {Range(0, 15)};
 870   EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
 871 }
 872
 873 TEST(Range, ReplacementsStartingAtRangeOffsets) {
 874   std::vector<Range> Ranges = {Range(0, 2), Range(5, 5), Range(15, 5)};
 875   Replacements Replaces = toReplacements(
 876       {Replacement("foo", 0, 2, "12"), Replacement("foo", 5, 1, "123"),
 877        Replacement("foo", 7, 4, "12345"), Replacement("foo", 15, 10, "12")});
 878   std::vector<Range> Expected = {Range(0, 2), Range(5, 9), Range(18, 2)};
 879   EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
 880 }
 881
 882 TEST(Range, ReplacementsEndingAtRangeEnds) {
 883   std::vector<Range> Ranges = {Range(0, 2), Range(5, 2), Range(15, 5)};
 884   Replacements Replaces = toReplacements(
 885       {Replacement("foo", 6, 1, "123"), Replacement("foo", 17, 3, "12")});
 886   std::vector<Range> Expected = {Range(0, 2), Range(5, 4), Range(17, 4)};
 887   EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
 888 }
 889
 890 TEST(Range, AjacentReplacements) {
 891   std::vector<Range> Ranges = {Range(0, 0), Range(15, 5)};
 892   Replacements Replaces = toReplacements(
 893       {Replacement("foo", 1, 2, "123"), Replacement("foo", 12, 3, "1234")});
 894   std::vector<Range> Expected = {Range(0, 0), Range(1, 3), Range(13, 9)};
 895   EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
 896 }
 897
 898 TEST(Range, MergeRangesAfterReplacements) {
 899   std::vector<Range> Ranges = {Range(8, 0), Range(5, 2), Range(9, 0), Range(0, 1)};
 900   Replacements Replaces = toReplacements({Replacement("foo", 1, 3, ""),
 901                                           Replacement("foo", 7, 0, "12"),
 902                                           Replacement("foo", 9, 2, "")});
 903   std::vector<Range> Expected = {Range(0, 1), Range(2, 4), Range(7, 0),
 904                                  Range(8, 0)};
 905   EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
 906 }
 907
 908 TEST(Range, ConflictingRangesBeforeReplacements) {
 909   std::vector<Range> Ranges = {Range(8, 3), Range(5, 4), Range(9, 1)};
 910   Replacements Replaces = toReplacements({Replacement("foo", 1, 3, "")});
 911   std::vector<Range> Expected = {Range(1, 0), Range(2, 6)};
 912   EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
 913 }
 914
 915 class MergeReplacementsTest : public ::testing::Test {
 916 protected:
 917   void mergeAndTestRewrite(StringRef Code, StringRef Intermediate,
 918                            StringRef Result, const Replacements &First,
 919                            const Replacements &Second) {
 920     // These are mainly to verify the test itself and make it easier to read.
 921     auto AfterFirst = applyAllReplacements(Code, First);
 922     EXPECT_TRUE(static_cast<bool>(AfterFirst));
 923     auto InSequenceRewrite = applyAllReplacements(*AfterFirst, Second);
 924     EXPECT_TRUE(static_cast<bool>(InSequenceRewrite));
 925     EXPECT_EQ(Intermediate, *AfterFirst);
 926     EXPECT_EQ(Result, *InSequenceRewrite);
 927
 928     tooling::Replacements Merged = First.merge(Second);
 929     auto MergedRewrite = applyAllReplacements(Code, Merged);
 930     EXPECT_TRUE(static_cast<bool>(MergedRewrite));
 931     EXPECT_EQ(*InSequenceRewrite, *MergedRewrite);
 932     if (*InSequenceRewrite != *MergedRewrite)
 933       for (tooling::Replacement M : Merged)
 934         llvm::errs() << M.getOffset() << " " << M.getLength() << " "
 935                      << M.getReplacementText() << "\n";
 936   }
 937   void mergeAndTestRewrite(StringRef Code, const Replacements &First,
 938                            const Replacements &Second) {
 939     auto AfterFirst = applyAllReplacements(Code, First);
 940     EXPECT_TRUE(static_cast<bool>(AfterFirst));
 941     auto InSequenceRewrite = applyAllReplacements(*AfterFirst, Second);
 942     tooling::Replacements Merged = First.merge(Second);
 943     auto MergedRewrite = applyAllReplacements(Code, Merged);
 944     EXPECT_TRUE(static_cast<bool>(MergedRewrite));
 945     EXPECT_EQ(*InSequenceRewrite, *MergedRewrite);
 946     if (*InSequenceRewrite != *MergedRewrite)
 947       for (tooling::Replacement M : Merged)
 948         llvm::errs() << M.getOffset() << " " << M.getLength() << " "
 949                      << M.getReplacementText() << "\n";
 950   }
 951 };
 952
 953 TEST_F(MergeReplacementsTest, Offsets) {
 954   mergeAndTestRewrite("aaa", "aabab", "cacabab",
 955                       toReplacements({{"", 2, 0, "b"}, {"", 3, 0, "b"}}),
 956                       toReplacements({{"", 0, 0, "c"}, {"", 1, 0, "c"}}));
 957   mergeAndTestRewrite("aaa", "babaa", "babacac",
 958                       toReplacements({{"", 0, 0, "b"}, {"", 1, 0, "b"}}),
 959                       toReplacements({{"", 4, 0, "c"}, {"", 5, 0, "c"}}));
 960   mergeAndTestRewrite("aaaa", "aaa", "aac", toReplacements({{"", 1, 1, ""}}),
 961                       toReplacements({{"", 2, 1, "c"}}));
 962
 963   mergeAndTestRewrite("aa", "bbabba", "bbabcba",
 964                       toReplacements({{"", 0, 0, "bb"}, {"", 1, 0, "bb"}}),
 965                       toReplacements({{"", 4, 0, "c"}}));
 966 }
 967
 968 TEST_F(MergeReplacementsTest, Concatenations) {
 969   // Basic concatenations. It is important to merge these into a single
 970   // replacement to ensure the correct order.
 971   {
 972     auto First = toReplacements({{"", 0, 0, "a"}});
 973     auto Second = toReplacements({{"", 1, 0, "b"}});
 974     EXPECT_EQ(toReplacements({{"", 0, 0, "ab"}}), First.merge(Second));
 975   }
 976   {
 977     auto First = toReplacements({{"", 0, 0, "a"}});
 978     auto Second = toReplacements({{"", 0, 0, "b"}});
 979     EXPECT_EQ(toReplacements({{"", 0, 0, "ba"}}), First.merge(Second));
 980   }
 981   mergeAndTestRewrite("", "a", "ab", toReplacements({{"", 0, 0, "a"}}),
 982                       toReplacements({{"", 1, 0, "b"}}));
 983   mergeAndTestRewrite("", "a", "ba", toReplacements({{"", 0, 0, "a"}}),
 984                       toReplacements({{"", 0, 0, "b"}}));
 985 }
 986
 987 TEST_F(MergeReplacementsTest, NotChangingLengths) {
 988   mergeAndTestRewrite("aaaa", "abba", "acca",
 989                       toReplacements({{"", 1, 2, "bb"}}),
 990                       toReplacements({{"", 1, 2, "cc"}}));
 991   mergeAndTestRewrite("aaaa", "abba", "abcc",
 992                       toReplacements({{"", 1, 2, "bb"}}),
 993                       toReplacements({{"", 2, 2, "cc"}}));
 994   mergeAndTestRewrite("aaaa", "abba", "ccba",
 995                       toReplacements({{"", 1, 2, "bb"}}),
 996                       toReplacements({{"", 0, 2, "cc"}}));
 997   mergeAndTestRewrite("aaaaaa", "abbdda", "abccda",
 998                       toReplacements({{"", 1, 2, "bb"}, {"", 3, 2, "dd"}}),
 999                       toReplacements({{"", 2, 2, "cc"}}));
1000 }
1001
1002 TEST_F(MergeReplacementsTest, OverlappingRanges) {
1003   mergeAndTestRewrite("aaa", "bbd", "bcbcd",
1004                       toReplacements({{"", 0, 1, "bb"}, {"", 1, 2, "d"}}),
1005                       toReplacements({{"", 1, 0, "c"}, {"", 2, 0, "c"}}));
1006
1007   mergeAndTestRewrite("aaaa", "aabbaa", "acccca",
1008                       toReplacements({{"", 2, 0, "bb"}}),
1009                       toReplacements({{"", 1, 4, "cccc"}}));
1010   mergeAndTestRewrite("aaaa", "aababa", "acccca",
1011                       toReplacements({{"", 2, 0, "b"}, {"", 3, 0, "b"}}),
1012                       toReplacements({{"", 1, 4, "cccc"}}));
1013   mergeAndTestRewrite("aaaaaa", "abbbba", "abba",
1014                       toReplacements({{"", 1, 4, "bbbb"}}),
1015                       toReplacements({{"", 2, 2, ""}}));
1016   mergeAndTestRewrite("aaaa", "aa", "cc",
1017                       toReplacements({{"", 1, 1, ""}, {"", 2, 1, ""}}),
1018                       toReplacements({{"", 0, 2, "cc"}}));
1019   mergeAndTestRewrite("aa", "abbba", "abcbcba",
1020                       toReplacements({{"", 1, 0, "bbb"}}),
1021                       toReplacements({{"", 2, 0, "c"}, {"", 3, 0, "c"}}));
1022
1023   mergeAndTestRewrite(
1024       "aaa", "abbab", "ccdd",
1025       toReplacements({{"", 0, 1, ""}, {"", 2, 0, "bb"}, {"", 3, 0, "b"}}),
1026       toReplacements({{"", 0, 2, "cc"}, {"", 2, 3, "dd"}}));
1027   mergeAndTestRewrite(
1028       "aa", "babbab", "ccdd",
1029       toReplacements({{"", 0, 0, "b"}, {"", 1, 0, "bb"}, {"", 2, 0, "b"}}),
1030       toReplacements({{"", 0, 3, "cc"}, {"", 3, 3, "dd"}}));
1031 }
1032
1033 TEST(DeduplicateByFileTest, PathsWithDots) {
1034   std::map<std::string, Replacements> FileToReplaces;
1035   llvm::IntrusiveRefCntPtr<vfs::InMemoryFileSystem> VFS(
1036       new vfs::InMemoryFileSystem());
1037   FileManager FileMgr(FileSystemOptions(), VFS);
1038 #if !defined(LLVM_ON_WIN32)
1039   StringRef Path1 = "a/b/.././c.h";
1040   StringRef Path2 = "a/c.h";
1041 #else
1042   StringRef Path1 = "a\\b\\..\\.\\c.h";
1043   StringRef Path2 = "a\\c.h";
1044 #endif
1045   EXPECT_TRUE(VFS->addFile(Path1, 0, llvm::MemoryBuffer::getMemBuffer("")));
1046   EXPECT_TRUE(VFS->addFile(Path2, 0, llvm::MemoryBuffer::getMemBuffer("")));
1047   FileToReplaces[Path1] = Replacements();
1048   FileToReplaces[Path2] = Replacements();
1049   FileToReplaces = groupReplacementsByFile(FileMgr, FileToReplaces);
1050   EXPECT_EQ(1u, FileToReplaces.size());
1051   EXPECT_EQ(Path1, FileToReplaces.begin()->first);
1052 }
1053
1054 TEST(DeduplicateByFileTest, PathWithDotSlash) {
1055   std::map<std::string, Replacements> FileToReplaces;
1056   llvm::IntrusiveRefCntPtr<vfs::InMemoryFileSystem> VFS(
1057       new vfs::InMemoryFileSystem());
1058   FileManager FileMgr(FileSystemOptions(), VFS);
1059 #if !defined(LLVM_ON_WIN32)
1060   StringRef Path1 = "./a/b/c.h";
1061   StringRef Path2 = "a/b/c.h";
1062 #else
1063   StringRef Path1 = ".\\a\\b\\c.h";
1064   StringRef Path2 = "a\\b\\c.h";
1065 #endif
1066   EXPECT_TRUE(VFS->addFile(Path1, 0, llvm::MemoryBuffer::getMemBuffer("")));
1067   EXPECT_TRUE(VFS->addFile(Path2, 0, llvm::MemoryBuffer::getMemBuffer("")));
1068   FileToReplaces[Path1] = Replacements();
1069   FileToReplaces[Path2] = Replacements();
1070   FileToReplaces = groupReplacementsByFile(FileMgr, FileToReplaces);
1071   EXPECT_EQ(1u, FileToReplaces.size());
1072   EXPECT_EQ(Path1, FileToReplaces.begin()->first);
1073 }
1074
1075 TEST(DeduplicateByFileTest, NonExistingFilePath) {
1076   std::map<std::string, Replacements> FileToReplaces;
1077   llvm::IntrusiveRefCntPtr<vfs::InMemoryFileSystem> VFS(
1078       new vfs::InMemoryFileSystem());
1079   FileManager FileMgr(FileSystemOptions(), VFS);
1080 #if !defined(LLVM_ON_WIN32)
1081   StringRef Path1 = "./a/b/c.h";
1082   StringRef Path2 = "a/b/c.h";
1083 #else
1084   StringRef Path1 = ".\\a\\b\\c.h";
1085   StringRef Path2 = "a\\b\\c.h";
1086 #endif
1087   FileToReplaces[Path1] = Replacements();
1088   FileToReplaces[Path2] = Replacements();
1089   FileToReplaces = groupReplacementsByFile(FileMgr, FileToReplaces);
1090   EXPECT_TRUE(FileToReplaces.empty());
1091 }
1092
1093 class AtomicChangeTest : public ::testing::Test {
1094   protected:
1095     void SetUp() override {
1096       DefaultFileID = Context.createInMemoryFile("input.cpp", DefaultCode);
1097       DefaultLoc = Context.Sources.getLocForStartOfFile(DefaultFileID)
1098                        .getLocWithOffset(20);
1099       assert(DefaultLoc.isValid() && "Default location must be valid.");
1100     }
1101
1102     RewriterTestContext Context;
1103     std::string DefaultCode = std::string(100, 'a');
1104     unsigned DefaultOffset = 20;
1105     SourceLocation DefaultLoc;
1106     FileID DefaultFileID;
1107 };
1108
1109 TEST_F(AtomicChangeTest, AtomicChangeToYAML) {
1110   AtomicChange Change(Context.Sources, DefaultLoc);
1111   llvm::Error Err =
1112       Change.insert(Context.Sources, DefaultLoc, "aa", /*InsertAfter=*/false);
1113   ASSERT_TRUE(!Err);
1114   Err = Change.insert(Context.Sources, DefaultLoc.getLocWithOffset(10), "bb",
1115                     /*InsertAfter=*/false);
1116   ASSERT_TRUE(!Err);
1117   Change.addHeader("a.h");
1118   Change.removeHeader("b.h");
1119   std::string YAMLString = Change.toYAMLString();
1120
1121   // NOTE: If this test starts to fail for no obvious reason, check whitespace.
1122   ASSERT_STREQ("---\n"
1123                "Key:             'input.cpp:20'\n"
1124                "FilePath:        input.cpp\n"
1125                "Error:           ''\n"
1126                "InsertedHeaders: [ a.h ]\n"
1127                "RemovedHeaders:  [ b.h ]\n"
1128                "Replacements:    \n" // Extra whitespace here!
1129                "  - FilePath:        input.cpp\n"
1130                "    Offset:          20\n"
1131                "    Length:          0\n"
1132                "    ReplacementText: aa\n"
1133                "  - FilePath:        input.cpp\n"
1134                "    Offset:          30\n"
1135                "    Length:          0\n"
1136                "    ReplacementText: bb\n"
1137                "...\n",
1138                YAMLString.c_str());
1139 }
1140
1141 TEST_F(AtomicChangeTest, YAMLToAtomicChange) {
1142   std::string YamlContent = "---\n"
1143                             "Key:             'input.cpp:20'\n"
1144                             "FilePath:        input.cpp\n"
1145                             "Error:           'ok'\n"
1146                             "InsertedHeaders: [ a.h ]\n"
1147                             "RemovedHeaders:  [ b.h ]\n"
1148                             "Replacements:    \n" // Extra whitespace here!
1149                             "  - FilePath:        input.cpp\n"
1150                             "    Offset:          20\n"
1151                             "    Length:          0\n"
1152                             "    ReplacementText: aa\n"
1153                             "  - FilePath:        input.cpp\n"
1154                             "    Offset:          30\n"
1155                             "    Length:          0\n"
1156                             "    ReplacementText: bb\n"
1157                             "...\n";
1158   AtomicChange ExpectedChange(Context.Sources, DefaultLoc);
1159   llvm::Error Err = ExpectedChange.insert(Context.Sources, DefaultLoc, "aa",
1160                                         /*InsertAfter=*/false);
1161   ASSERT_TRUE(!Err);
1162   Err = ExpectedChange.insert(Context.Sources, DefaultLoc.getLocWithOffset(10),
1163                             "bb", /*InsertAfter=*/false);
1164   ASSERT_TRUE(!Err);
1165
1166   ExpectedChange.addHeader("a.h");
1167   ExpectedChange.removeHeader("b.h");
1168   ExpectedChange.setError("ok");
1169
1170   AtomicChange ActualChange = AtomicChange::convertFromYAML(YamlContent);
1171   EXPECT_EQ(ExpectedChange.getKey(), ActualChange.getKey());
1172   EXPECT_EQ(ExpectedChange.getFilePath(), ActualChange.getFilePath());
1173   EXPECT_EQ(ExpectedChange.getError(), ActualChange.getError());
1174   EXPECT_EQ(ExpectedChange.getInsertedHeaders(),
1175             ActualChange.getInsertedHeaders());
1176   EXPECT_EQ(ExpectedChange.getRemovedHeaders(),
1177             ActualChange.getRemovedHeaders());
1178   EXPECT_EQ(ExpectedChange.getReplacements().size(),
1179             ActualChange.getReplacements().size());
1180   EXPECT_EQ(2u, ActualChange.getReplacements().size());
1181   EXPECT_EQ(*ExpectedChange.getReplacements().begin(),
1182             *ActualChange.getReplacements().begin());
1183   EXPECT_EQ(*(++ExpectedChange.getReplacements().begin()),
1184             *(++ActualChange.getReplacements().begin()));
1185 }
1186
1187 TEST_F(AtomicChangeTest, CheckKeyAndKeyFile) {
1188   AtomicChange Change(Context.Sources, DefaultLoc);
1189   EXPECT_EQ("input.cpp:20", Change.getKey());
1190   EXPECT_EQ("input.cpp", Change.getFilePath());
1191 }
1192
1193 TEST_F(AtomicChangeTest, Replace) {
1194   AtomicChange Change(Context.Sources, DefaultLoc);
1195   llvm::Error Err = Change.replace(Context.Sources, DefaultLoc, 2, "aa");
1196   ASSERT_TRUE(!Err);
1197   EXPECT_EQ(Change.getReplacements().size(), 1u);
1198   EXPECT_EQ(*Change.getReplacements().begin(),
1199             Replacement(Context.Sources, DefaultLoc, 2, "aa"));
1200
1201   // Add a new replacement that conflicts with the existing one.
1202   Err = Change.replace(Context.Sources, DefaultLoc, 3, "ab");
1203   EXPECT_TRUE((bool)Err);
1204   llvm::consumeError(std::move(Err));
1205   EXPECT_EQ(Change.getReplacements().size(), 1u);
1206 }
1207
1208 TEST_F(AtomicChangeTest, ReplaceWithRange) {
1209   AtomicChange Change(Context.Sources, DefaultLoc);
1210   SourceLocation End = DefaultLoc.getLocWithOffset(20);
1211   llvm::Error Err = Change.replace(
1212       Context.Sources, CharSourceRange::getCharRange(DefaultLoc, End), "aa");
1213   ASSERT_TRUE(!Err);
1214   EXPECT_EQ(Change.getReplacements().size(), 1u);
1215   EXPECT_EQ(*Change.getReplacements().begin(),
1216             Replacement(Context.Sources, DefaultLoc, 20, "aa"));
1217 }
1218
1219 TEST_F(AtomicChangeTest, InsertBefore) {
1220   AtomicChange Change(Context.Sources, DefaultLoc);
1221   llvm::Error Err = Change.insert(Context.Sources, DefaultLoc, "aa");
1222   ASSERT_TRUE(!Err);
1223   EXPECT_EQ(Change.getReplacements().size(), 1u);
1224   EXPECT_EQ(*Change.getReplacements().begin(),
1225             Replacement(Context.Sources, DefaultLoc, 0, "aa"));
1226   Err = Change.insert(Context.Sources, DefaultLoc, "b", /*InsertAfter=*/false);
1227   ASSERT_TRUE(!Err);
1228   EXPECT_EQ(Change.getReplacements().size(), 1u);
1229   EXPECT_EQ(*Change.getReplacements().begin(),
1230             Replacement(Context.Sources, DefaultLoc, 0, "baa"));
1231 }
1232
1233 TEST_F(AtomicChangeTest, InsertAfter) {
1234   AtomicChange Change(Context.Sources, DefaultLoc);
1235   llvm::Error Err = Change.insert(Context.Sources, DefaultLoc, "aa");
1236   ASSERT_TRUE(!Err);
1237   EXPECT_EQ(Change.getReplacements().size(), 1u);
1238   EXPECT_EQ(*Change.getReplacements().begin(),
1239             Replacement(Context.Sources, DefaultLoc, 0, "aa"));
1240   Err = Change.insert(Context.Sources, DefaultLoc, "b");
1241   ASSERT_TRUE(!Err);
1242   EXPECT_EQ(Change.getReplacements().size(), 1u);
1243   EXPECT_EQ(*Change.getReplacements().begin(),
1244             Replacement(Context.Sources, DefaultLoc, 0, "aab"));
1245 }
1246
1247 TEST_F(AtomicChangeTest, InsertBeforeWithInvalidLocation) {
1248   AtomicChange Change(Context.Sources, DefaultLoc);
1249   llvm::Error Err =
1250       Change.insert(Context.Sources, DefaultLoc, "a", /*InsertAfter=*/false);
1251   ASSERT_TRUE(!Err);
1252
1253   // Invalid location.
1254   Err = Change.insert(Context.Sources, SourceLocation(), "a",
1255                     /*InsertAfter=*/false);
1256   ASSERT_TRUE((bool)Err);
1257   EXPECT_TRUE(checkReplacementError(
1258       std::move(Err), replacement_error::wrong_file_path,
1259       Replacement(Context.Sources, DefaultLoc, 0, "a"),
1260       Replacement(Context.Sources, SourceLocation(), 0, "a")));
1261 }
1262
1263 TEST_F(AtomicChangeTest, InsertBeforeToWrongFile) {
1264   AtomicChange Change(Context.Sources, DefaultLoc);
1265   llvm::Error Err =
1266       Change.insert(Context.Sources, DefaultLoc, "a", /*InsertAfter=*/false);
1267   ASSERT_TRUE(!Err);
1268
1269   // Inserting at a different file.
1270   FileID NewID = Context.createInMemoryFile("extra.cpp", DefaultCode);
1271   SourceLocation NewLoc = Context.Sources.getLocForStartOfFile(NewID);
1272   Err = Change.insert(Context.Sources, NewLoc, "b", /*InsertAfter=*/false);
1273   ASSERT_TRUE((bool)Err);
1274   EXPECT_TRUE(
1275       checkReplacementError(std::move(Err), replacement_error::wrong_file_path,
1276                             Replacement(Context.Sources, DefaultLoc, 0, "a"),
1277                             Replacement(Context.Sources, NewLoc, 0, "b")));
1278 }
1279
1280 TEST_F(AtomicChangeTest, InsertAfterWithInvalidLocation) {
1281   AtomicChange Change(Context.Sources, DefaultLoc);
1282   llvm::Error Err = Change.insert(Context.Sources, DefaultLoc, "a");
1283   ASSERT_TRUE(!Err);
1284
1285   // Invalid location.
1286   Err = Change.insert(Context.Sources, SourceLocation(), "b");
1287   ASSERT_TRUE((bool)Err);
1288   EXPECT_TRUE(checkReplacementError(
1289       std::move(Err), replacement_error::wrong_file_path,
1290       Replacement(Context.Sources, DefaultLoc, 0, "a"),
1291       Replacement(Context.Sources, SourceLocation(), 0, "b")));
1292 }
1293
1294 } // end namespace tooling
1295 } // end namespace clang