Replace clang::tooling::Replacements with std::set<clang::tooling::Replacement>.

tools/clang/rewrite_to_chrome_style/RewriteToChromeStyle.cpp

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
 // Changes Blink-style names to Chrome-style names. Currently transforms:
 //   fields:
 //     int m_operationCount => int operation_count_
 //   variables (including parameters):
 //     int mySuperVariable => int my_super_variable
 //   constants:
@@ skipping 476 matching lines @@
   static const char* GetName() { return "expr"; }
   static const char* GetType() { return "UnresolvedMemberExpr"; }
 };
 
 template <typename DeclNode, typename TargetNode>
 class RewriterBase : public MatchFinder::MatchCallback {
  public:
   explicit RewriterBase(Replacements* replacements)
       : replacements_(replacements) {}
 
+  void addReplacementIfNeeded(const Replacement& new_replacement) {
+    // Ignore the replacement if it is a duplicate.
+    bool is_same_replacement_already_present = std::any_of(
+        replacements_->begin(), replacements_->end(),
+        [&new_replacement](const Replacement& old_replacement) {
+          return new_replacement.toString() == old_replacement.toString();

[Łukasz Anforowicz, 2016/08/16 22:24:16]

Replacement doesn't define ==.  And Replacements doesn't have |contains| or
|find| method.  Therefore - I end up with an ugly std::any_of and with
x.toString() == y.toString().  :-(

+        });
+    if (is_same_replacement_already_present)
+      return;

[Łukasz Anforowicz, 2016/08/16 22:24:16]

If we didn't check |is_same_replacement_already_present|, then the new
|Replacements::add| method would fail saying (in |err.toString()|) something
like:

New replacement:
/usr/local/google/home/lukasza/src/chromium4/src/tools/clang/rewrite_to_chrome_style/tests/methods-actual.cc:
2635:+5:"ptr_"
conflicts with existing replacement:
/usr/local/google/home/lukasza/src/chromium4/src/tools/clang/rewrite_to_chrome_style/tests/methods-actual.cc:
2635:+5:"ptr_"

+
+    // Try to add the replacement
+    if (llvm::Error err = replacements_->add(new_replacement)) {
+      llvm::outs() << "Replacements::add failed: "
+                   << toString(std::move(err)) << "\n";
+      assert(false);  // Order-dependent replacements?
+      return;

[Łukasz Anforowicz, 2016/08/16 22:24:16]

I am not sure how I should spell a fatal failure...

+    }
+  }
+
   void run(const MatchFinder::MatchResult& result) override {
     const DeclNode* decl = result.Nodes.getNodeAs<DeclNode>("decl");
     // If false, there's no name to be renamed.
     if (!decl->getIdentifier())
       return;
     clang::SourceLocation decl_loc =
         TargetNodeTraits<clang::NamedDecl>::GetLoc(*decl);
     if (decl_loc.isMacroID()) {
       // Get the location of the spelling of the declaration. If token pasting
       // was used this will be in "scratch space" and we don't know how to get
       // from there back to/ the actual macro with the foo##bar text. So just
       // don't replace in that case.
       clang::SourceLocation spell =
           result.SourceManager->getSpellingLoc(decl_loc);
       if (strcmp(result.SourceManager->getBufferName(spell),
                  "<scratch space>") == 0)
         return;
     }
     clang::ASTContext* context = result.Context;
     std::string new_name;
     if (!GetNameForDecl(*decl, *context, new_name))
       return;  // If false, the name was not suitable for renaming.
     llvm::StringRef old_name = decl->getName();
     if (old_name == new_name)
       return;
     clang::SourceLocation loc = TargetNodeTraits<TargetNode>::GetLoc(
         *result.Nodes.getNodeAs<TargetNode>(
             TargetNodeTraits<TargetNode>::GetName()));
     clang::CharSourceRange range = clang::CharSourceRange::getTokenRange(loc);
-    replacements_->emplace(*result.SourceManager, range, new_name);
+    addReplacementIfNeeded(Replacement(*result.SourceManager, range, new_name));
     replacement_names_.emplace(old_name.str(), std::move(new_name));
   }
 
   const std::unordered_map<std::string, std::string>& replacement_names()
       const {
     return replacement_names_;
   }
 
  private:
   Replacements* const replacements_;
@@ skipping 343 matching lines @@
   for (const auto& r : replacements) {
     std::string replacement_text = r.getReplacementText().str();
     std::replace(replacement_text.begin(), replacement_text.end(), '\n', '\0');
     llvm::outs() << "r:::" << r.getFilePath() << ":::" << r.getOffset()
                  << ":::" << r.getLength() << ":::" << replacement_text << "\n";
   }
   llvm::outs() << "==== END EDITS ====\n";
 
   return 0;
 }