Changes related to new implementation of tooling::Replacements as class.

[ioeric]

Summary

See http://reviews.llvm.org/D21748 for details.

[ioeric]

• Fixed broken build in clang-rename

[ioeric]

• Merged with orgin/master

[ioeric]

• merged with origin/master
• Addressed reviewer's comments in the corresponding patch.

[ioeric]

• Merged with origin/master.

[ioeric]

• Minor cleanup/

[klimek]

lg

[ioeric]

• merged with origin/master

clang-apply-replacements/include/clang-apply-replacements/Tooling/ApplyReplacements.h

 ///
 /// \returns \parblock
 ///          \li true If all changes were applied successfully.
 ///          \li false If there were conflicts.
 bool mergeAndDeduplicate(const TUReplacements &TUs,
                          FileToReplacementsMap &GroupedReplacements,
                          clang::SourceManager &SM);
 
+// FIXME: Remove this function after changing clang-apply-replacements to use
+// Replacements class.
+bool applyAllReplacements(const std::vector<tooling::Replacement> &Replaces,
+                          Rewriter &Rewrite);
+
 /// \brief Apply all replacements in \c GroupedReplacements.
 ///
 /// \param[in] GroupedReplacements Deduplicated and conflict free Replacements
 /// to apply.
 /// \param[out] Rewrites The results of applying replacements will be applied
 /// to this Rewriter.
 ///
 /// \returns \parblock

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

if (R.getLength() == 0) {
       if (R.getReplacementText().empty())
         errs() << "\n";
       else
         errs() << " with \"" << R.getReplacementText() << "\"\n";
     }
   }
 }
 
+// FIXME: Remove this function after changing clang-apply-replacements to use
+// Replacements class.
+bool applyAllReplacements(const std::vector<tooling::Replacement> &Replaces,
+                          Rewriter &Rewrite) {
+  bool Result = true;
+  for (std::vector<tooling::Replacement>::const_iterator I = Replaces.begin(),
+                                                E = Replaces.end();
+       I != E; ++I) {
+    if (I->isApplicable()) {
+      Result = I->apply(Rewrite) && Result;
+    } else {
+      Result = false;
+    }
+  }
+  return Result;
+}
+
+
+// FIXME: moved from libToolingCore. remove this when std::vector<Replacement>
+// is replaced with tooling::Replacements class.
+static void deduplicate(std::vector<tooling::Replacement> &Replaces,
+                 std::vector<tooling::Range> &Conflicts) {
+  if (Replaces.empty())
+    return;
+
+  auto LessNoPath = [](const tooling::Replacement &LHS,
+                       const tooling::Replacement &RHS) {
+    if (LHS.getOffset() != RHS.getOffset())
+      return LHS.getOffset() < RHS.getOffset();
+    if (LHS.getLength() != RHS.getLength())
+      return LHS.getLength() < RHS.getLength();
+    return LHS.getReplacementText() < RHS.getReplacementText();
+  };
+
+  auto EqualNoPath = [](const tooling::Replacement &LHS,
+                        const tooling::Replacement &RHS) {
+    return LHS.getOffset() == RHS.getOffset() &&
+           LHS.getLength() == RHS.getLength() &&
+           LHS.getReplacementText() == RHS.getReplacementText();
+  };
+
+  // Deduplicate. We don't want to deduplicate based on the path as we assume
+  // that all replacements refer to the same file (or are symlinks).
+  std::sort(Replaces.begin(), Replaces.end(), LessNoPath);
+  Replaces.erase(std::unique(Replaces.begin(), Replaces.end(), EqualNoPath),
+                 Replaces.end());
+
+  // Detect conflicts
+  tooling::Range ConflictRange(Replaces.front().getOffset(),
+                               Replaces.front().getLength());
+  unsigned ConflictStart = 0;
+  unsigned ConflictLength = 1;
+  for (unsigned i = 1; i < Replaces.size(); ++i) {
+    tooling::Range Current(Replaces[i].getOffset(), Replaces[i].getLength());
+    if (ConflictRange.overlapsWith(Current)) {
+      // Extend conflicted range
+      ConflictRange =
+          tooling::Range(ConflictRange.getOffset(),
+                         std::max(ConflictRange.getLength(),
+                                  Current.getOffset() + Current.getLength() -
+                                      ConflictRange.getOffset()));
+      ++ConflictLength;
+    } else {
+      if (ConflictLength > 1)
+        Conflicts.push_back(tooling::Range(ConflictStart, ConflictLength));
+      ConflictRange = Current;
+      ConflictStart = i;
+      ConflictLength = 1;
+    }
+  }
+
+  if (ConflictLength > 1)
+    Conflicts.push_back(tooling::Range(ConflictStart, ConflictLength));
+}
+
 /// \brief Deduplicates and tests for conflicts among the replacements for each
 /// file in \c Replacements. Any conflicts found are reported.
 ///
 /// \post Replacements[i].getOffset() <= Replacements[i+1].getOffset().
 ///
 /// \param[in,out] Replacements Container of all replacements grouped by file
 /// to be deduplicated and checked for conflicts.
 /// \param[in] SM SourceManager required for conflict reporting.
 ///
 /// \returns \parblock
 ///          \li true if conflicts were detected
 ///          \li false if no conflicts were detected
 static bool deduplicateAndDetectConflicts(FileToReplacementsMap &Replacements,
                                           SourceManager &SM) {
   bool conflictsFound = false;
 
   for (auto &FileAndReplacements : Replacements) {
     const FileEntry *Entry = FileAndReplacements.first;
     auto &Replacements = FileAndReplacements.second;
     assert(Entry != nullptr && "No file entry!");
 
     std::vector<tooling::Range> Conflicts;
-    tooling::deduplicate(FileAndReplacements.second, Conflicts);
+    deduplicate(FileAndReplacements.second, Conflicts);
 
     if (Conflicts.empty())
       continue;
 
     conflictsFound = true;
 
     errs() << "There are conflicting changes to " << Entry->getName() << ":\n";
 
bool applyReplacements(const FileToReplacementsMap &GroupedReplacements,
 
   // Apply all changes
   //
   // FIXME: No longer certain GroupedReplacements is really the best kind of
   // data structure for applying replacements. Rewriter certainly doesn't care.
   // However, until we nail down the design of ReplacementGroups, might as well
   // leave this as is.
   for (const auto &FileAndReplacements : GroupedReplacements) {
-    if (!tooling::applyAllReplacements(FileAndReplacements.second, Rewrites))
+    if (!applyAllReplacements(FileAndReplacements.second, Rewrites))
       return false;
   }
 
   return true;
 }
 
 RangeVector calculateChangedRanges(
     const std::vector<clang::tooling::Replacement> &Replaces) {

clang-apply-replacements/tool/ClangApplyReplacementsMain.cpp

 /// \returns \parblock
 ///          \li true if all replacements were applied successfully.
 ///          \li false if at least one replacement failed to apply.
 static bool
 getRewrittenData(const std::vector<tooling::Replacement> &Replacements,
                  Rewriter &Rewrites, std::string &Result) {
   if (Replacements.empty()) return true;
 
-  if (!tooling::applyAllReplacements(Replacements, Rewrites))
+  if (!applyAllReplacements(Replacements, Rewrites))
     return false;
 
   SourceManager &SM = Rewrites.getSourceMgr();
   FileManager &Files = SM.getFileManager();
 
   StringRef FileName = Replacements.begin()->getFilePath();
   const clang::FileEntry *Entry = Files.getFile(FileName);
   assert(Entry && "Expected an existing file");

clang-rename/RenamingAction.h

 class CompilerInstance;
 
 namespace rename {
 
 class RenamingAction {
 public:
   RenamingAction(const std::string &NewName, const std::string &PrevName,
                  const std::vector<std::string> &USRs,
-                 tooling::Replacements &Replaces, bool PrintLocations = false)
-      : NewName(NewName), PrevName(PrevName), USRs(USRs), Replaces(Replaces),
-        PrintLocations(PrintLocations) {
-  }
+                 std::map<std::string, tooling::Replacements> &FileToReplaces,
+                 bool PrintLocations = false)
+      : NewName(NewName), PrevName(PrevName), USRs(USRs),
+        FileToReplaces(FileToReplaces), PrintLocations(PrintLocations) {}
 
   std::unique_ptr<ASTConsumer> newASTConsumer();
 
 private:
   const std::string &NewName, &PrevName;
   const std::vector<std::string> &USRs;
-  tooling::Replacements &Replaces;
+  std::map<std::string, tooling::Replacements> &FileToReplaces;
   bool PrintLocations;
 };
 
 }
 }
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_RENAME_RENAMING_ACTION_H_

clang-rename/RenamingAction.cpp

 
 using namespace llvm;
 
 namespace clang {
 namespace rename {
 
 class RenamingASTConsumer : public ASTConsumer {
 public:
-  RenamingASTConsumer(const std::string &NewName, const std::string &PrevName,
-                      const std::vector<std::string> &USRs,
-                      tooling::Replacements &Replaces, bool PrintLocations)
-      : NewName(NewName), PrevName(PrevName), USRs(USRs), Replaces(Replaces),
-        PrintLocations(PrintLocations) {}
+  RenamingASTConsumer(
+      const std::string &NewName, const std::string &PrevName,
+      std::map<std::string, tooling::Replacements> &FileToReplaces,
+      bool PrintLocations)
+      : NewName(NewName), PrevName(PrevName), USRs(USRs),
+        FileToReplaces(FileToReplaces), PrintLocations(PrintLocations) {}
 
   void HandleTranslationUnit(ASTContext &Context) override {
     const auto &SourceMgr = Context.getSourceManager();
     std::vector<SourceLocation> RenamingCandidates;
     std::vector<SourceLocation> NewCandidates;
 
     NewCandidates =
         getLocationsOfUSRs(USRs, PrevName, Context.getTranslationUnitDecl());
     RenamingCandidates.insert(RenamingCandidates.end(), NewCandidates.begin(),
                               NewCandidates.end());
 
     auto PrevNameLen = PrevName.length();
     for (const auto &Loc : RenamingCandidates) {
       if (PrintLocations) {
         FullSourceLoc FullLoc(Loc, SourceMgr);
         errs() << "clang-rename: renamed at: " << SourceMgr.getFilename(Loc)
                << ":" << FullLoc.getSpellingLineNumber() << ":"
                << FullLoc.getSpellingColumnNumber() << "\n";
       }
-      Replaces.insert(
-          tooling::Replacement(SourceMgr, Loc, PrevNameLen, NewName));
+      // FIXME: better error handling.
+      auto Replace = tooling::Replacement(SourceMgr, Loc, PrevNameLen, NewName);
+      auto Err = FileToReplaces[Replace.getFilePath()].add(Replace);
+      if (Err)
+        llvm::errs() << "Renaming failed in " << Replace.getFilePath() << "! "
+                     << llvm::toString(std::move(Err)) << "\n";
     }
   }
 
 private:
   const std::string &NewName, &PrevName;
   const std::vector<std::string> &USRs;
-  tooling::Replacements &Replaces;
+  std::map<std::string, tooling::Replacements> &FileToReplaces;
   bool PrintLocations;
 };
 
 std::unique_ptr<ASTConsumer> RenamingAction::newASTConsumer() {
   return llvm::make_unique<RenamingASTConsumer>(NewName, PrevName, USRs,
-                                                Replaces, PrintLocations);
+                                                FileToReplaces, PrintLocations);
 }
 
 } // namespace rename
 } // namespace clang

clang-rename/tool/ClangRename.cpp

if (!ExportFixes.empty()) {
       llvm::raw_fd_ostream OS(ExportFixes, EC, llvm::sys::fs::F_None);
       if (EC) {
         llvm::errs() << "Error opening output file: " << EC.message() << '\n';
         exit(1);
       }
 
       // Export replacements.
       tooling::TranslationUnitReplacements TUR;
-      const tooling::Replacements &Replacements = Tool.getReplacements();
-      TUR.Replacements.insert(TUR.Replacements.end(), Replacements.begin(),
-                              Replacements.end());
+      const auto &FileToReplacements = Tool.getReplacements();
+      for (const auto &Entry : FileToReplacements)
+        TUR.Replacements.insert(TUR.Replacements.end(), Entry.second.begin(),
+                                Entry.second.end());
 
       yaml::Output YAML(OS);
       YAML << TUR;
       OS.close();
       exit(0);
     }
 
     // Write every file to stdout. Right now we just barf the files without any

clang-tidy/ClangTidyDiagnosticConsumer.cpp

void emitCodeContext(SourceLocation Loc, DiagnosticsEngine::Level Level,
     assert(Loc.isValid());
     for (const auto &FixIt : Hints) {
       CharSourceRange Range = FixIt.RemoveRange;
       assert(Range.getBegin().isValid() && Range.getEnd().isValid() &&
              "Invalid range in the fix-it hint.");
       assert(Range.getBegin().isFileID() && Range.getEnd().isFileID() &&
              "Only file locations supported in fix-it hints.");
 
-      Error.Fix.insert(tooling::Replacement(SM, Range, FixIt.CodeToInsert));
+      auto Err =
+          Error.Fix.add(tooling::Replacement(SM, Range, FixIt.CodeToInsert));
+      // FIXME: better error handling.
+      if (Err) {
+        llvm::errs() << "Fix conflicts with existing fix! "
+                    << llvm::toString(std::move(Err)) << "\n";
+      }
+      assert(!Err && "Fix conflicts with existing fix!");
     }
   }
 
   void emitIncludeLocation(SourceLocation Loc, PresumedLoc PLoc,
                            const SourceManager &SM) override {}
 
   void emitImportLocation(SourceLocation Loc, PresumedLoc PLoc,
                           StringRef ModuleName,

include-fixer/IncludeFixer.cpp

 llvm::Expected<tooling::Replacements> createIncludeFixerReplacements(
     StringRef Code, StringRef FilePath, const IncludeFixerContext &Context,
     const clang::format::FormatStyle &Style, bool AddQualifiers) {
   if (Context.getHeaderInfos().empty())
     return tooling::Replacements();
   std::string IncludeName =
       "#include " + Context.getHeaderInfos().front().Header + "\n";
   // Create replacements for the new header.
-  clang::tooling::Replacements Insertions = {
-      tooling::Replacement(FilePath, UINT_MAX, 0, IncludeName)};
+  clang::tooling::Replacements Insertions;
+  auto Err =
+      Insertions.add(tooling::Replacement(FilePath, UINT_MAX, 0, IncludeName));
+  if (Err)
+    return std::move(Err);
 
   auto CleanReplaces = cleanupAroundReplacements(Code, Insertions, Style);
   if (!CleanReplaces)
     return CleanReplaces;
 
+  auto Replaces = std::move(*CleanReplaces);
   if (AddQualifiers) {
     for (const auto &Info : Context.getQuerySymbolInfos()) {
       // Ignore the empty range.
-      if (Info.Range.getLength() > 0)
-        CleanReplaces->insert({FilePath, Info.Range.getOffset(),
-                               Info.Range.getLength(),
-                               Context.getHeaderInfos().front().QualifiedName});
+      if (Info.Range.getLength() > 0) {
+        auto R = tooling::Replacement(
+            {FilePath, Info.Range.getOffset(), Info.Range.getLength(),
+        auto Err = Replaces.add(R);
+        if (Err) {
+          llvm::consumeError(std::move(Err));
+          R = tooling::Replacement(
+              R.getFilePath(), Replaces.getShiftedCodePosition(R.getOffset()),
+              R.getLength(), R.getReplacementText());
+          Replaces = Replaces.merge(tooling::Replacements(R));
         }
       }
-  return formatReplacements(Code, *CleanReplaces, Style);
+    }
+  }
+  return formatReplacements(Code, Replaces, Style);
 }
 
 } // namespace include_fixer
 } // namespace clang

include-fixer/tool/ClangIncludeFixer.cpp

auto Replacements = clang::include_fixer::createIncludeFixerReplacements(
       /*Code=*/Buffer.get()->getBuffer(), FilePath, Context, InsertStyle);
   if (!Replacements) {
     errs() << "Failed to create header insertion replacement: "
            << llvm::toString(Replacements.takeError()) << "\n";
     return 1;
   }
 
   if (!Quiet)
-    errs() << "Added #include " << Context.getHeaderInfos().front().Header
-           << '\n';
+    llvm::errs() << "Added #include " << Context.getHeaderInfos().front().Header
+                 << "\n";
 
   // Set up a new source manager for applying the resulting replacements.
   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts(new DiagnosticOptions);
   DiagnosticsEngine Diagnostics(new DiagnosticIDs, &*DiagOpts);
   TextDiagnosticPrinter DiagnosticPrinter(outs(), &*DiagOpts);
   SourceManager SM(Diagnostics, tool.getFiles());
   Diagnostics.setClient(&DiagnosticPrinter, false);
 

tool-template/ToolTemplate.cpp

 
 using namespace clang;
 using namespace clang::ast_matchers;
 using namespace clang::tooling;
 using namespace llvm;
 
 namespace {
 class ToolTemplateCallback : public MatchFinder::MatchCallback {
- public:
-  ToolTemplateCallback(Replacements *Replace) : Replace(Replace) {}
+  ToolTemplateCallback(std::map<std::string, Replacements> *Replace)
+      : Replace(Replace) {}
 
   void run(const MatchFinder::MatchResult &Result) override {
-    // TODO: This routine will get called for each thing that the matchers find.
+    // TODO: This routine will get called for each thing that the matchers
+    // find.
     // At this point, you can examine the match, and do whatever you want,
     // including replacing the matched text with other text
     (void)Replace; // This to prevent an "unused member variable" warning;
   }
 
- private:
-  Replacements *Replace;
+  std::map<std::string, Replacements> *Replace;
 };
 } // end anonymous namespace
 
 // Set up the command line options
 static cl::extrahelp CommonHelp(CommonOptionsParser::HelpMessage);
 static cl::OptionCategory ToolTemplateCategory("tool-template options");
 
 int main(int argc, const char **argv) {

unittests/clang-tidy/ClangTidyTest.h

for (const auto &Error : Context.getErrors()) {
       ErrorText += Error.Message.Message + "\n";
     }
     llvm::report_fatal_error(ErrorText);
   }
 
   DiagConsumer.finish();
   tooling::Replacements Fixes;
   for (const ClangTidyError &Error : Context.getErrors())
-    Fixes.insert(Error.Fix.begin(), Error.Fix.end());
+    for (const auto &Fix : Error.Fix) {
+      auto Err = Fixes.add(Fix);
+      // FIXME: better error handling. Keep the behavior for now.
+      if (Err) {
+        llvm::errs() << llvm::toString(std::move(Err)) << "\n";
+        return "";
+      }
+    }
   if (Errors)
     *Errors = Context.getErrors();
   auto Result = tooling::applyAllReplacements(Code, Fixes);
   if (!Result) {
     // FIXME: propogate the error.
     llvm::consumeError(Result.takeError());
     return "";
   }