Emit edit tracking information from *all* rewriters.

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 1021 matching lines @@
       const clang::UnresolvedUsingValueDecl& decl) {
     return decl.getNameInfo().getLoc();
   }
   static const char* GetName() { return "decl"; }
   static const char* GetType() { return "UnresolvedUsingValueDecl"; }
 };
 
 template <typename TargetNode>
 class RewriterBase : public MatchFinder::MatchCallback {
  public:
-  explicit RewriterBase(std::set<Replacement>* replacements)
-      : replacements_(replacements) {}
+  explicit RewriterBase(std::set<Replacement>* replacements,
+                        RenameCategory category)
+      : replacements_(replacements), edit_tracker_(category) {}
 
   const TargetNode& GetTargetNode(const MatchFinder::MatchResult& result) {
     const TargetNode* target_node = result.Nodes.getNodeAs<TargetNode>(
         TargetNodeTraits<TargetNode>::GetName());
     assert(target_node);
     return *target_node;
   }
 
   bool GenerateReplacement(const MatchFinder::MatchResult& result,
                            clang::SourceLocation loc,
@@ skipping 65 matching lines @@
       return;
 
     Replacement replacement;
     if (!GenerateReplacement(result, loc, old_name, new_name, &replacement))
       return;
 
     replacements_->insert(std::move(replacement));
     edit_tracker_.Add(*result.SourceManager, loc, old_name, new_name);
   }
 
-  const EditTracker& edit_tracker() const { return edit_tracker_; }
+  const EditTracker* edit_tracker() const { return &edit_tracker_; }
 
  private:
   std::set<Replacement>* const replacements_;
   EditTracker edit_tracker_;
 };
 
+template <typename DeclNode>
+RenameCategory GetCategory();
+template <>
+RenameCategory GetCategory<clang::FieldDecl>() {
+  return RenameCategory::kField;
+}
+template <>
+RenameCategory GetCategory<clang::VarDecl>() {
+  return RenameCategory::kVariable;
+}
+template <>
+RenameCategory GetCategory<clang::FunctionDecl>() {
+  return RenameCategory::kFunction;
+}
+template <>
+RenameCategory GetCategory<clang::CXXMethodDecl>() {
+  return RenameCategory::kFunction;
+}
+template <>
+RenameCategory GetCategory<clang::EnumConstantDecl>() {
+  return RenameCategory::kEnumValue;
+}
+template <>
+RenameCategory GetCategory<clang::NamedDecl>() {
+  return RenameCategory::kUnresolved;
+}
+template <>
+RenameCategory GetCategory<clang::UsingDecl>() {
+  return RenameCategory::kUnresolved;
+}
+
 template <typename DeclNode, typename TargetNode>
 class DeclRewriterBase : public RewriterBase<TargetNode> {
  public:
   using Base = RewriterBase<TargetNode>;
 
   explicit DeclRewriterBase(std::set<Replacement>* replacements)
-      : Base(replacements) {}
+      : Base(replacements, GetCategory<DeclNode>()) {}
 
   void run(const MatchFinder::MatchResult& result) override {
     const DeclNode* decl = result.Nodes.getNodeAs<DeclNode>("decl");
     if (!decl->getDeclName().isIdentifier())
       return;
 
     assert(decl);
     llvm::StringRef old_name = decl->getName();
 
     // Return early if there's no name to be renamed.
@@ skipping 166 matching lines @@
   // that |using Base::foo| refers to a method.
   return true;
 }
 
 template <typename TargetNode>
 class UnresolvedRewriterBase : public RewriterBase<TargetNode> {
  public:
   using Base = RewriterBase<TargetNode>;
 
   explicit UnresolvedRewriterBase(std::set<Replacement>* replacements)
-      : RewriterBase<TargetNode>(replacements) {}
+      : RewriterBase<TargetNode>(replacements, RenameCategory::kUnresolved) {}
 
   void run(const MatchFinder::MatchResult& result) override {
     const TargetNode& node = Base::GetTargetNode(result);
 
     clang::DeclarationName decl_name = GetUnresolvedName(node);
     switch (decl_name.getNameKind()) {
       // Do not rewrite this:
       //   return operator T*();
       // into this:
       //   return Operator type - parameter - 0 - 0 * T * ();
@@ skipping 497 matching lines @@
   // Prepare and run the tool.
   SourceFileCallbacks source_file_callbacks(&gmock_member_rewriter);
   std::unique_ptr<clang::tooling::FrontendActionFactory> factory =
       clang::tooling::newFrontendActionFactory(&match_finder,
                                                &source_file_callbacks);
   int result = tool.run(factory.get());
   if (result != 0)
     return result;
 
   // Supplemental data for the Blink rename rebase helper.
-  // TODO(dcheng): There's a lot of match rewriters missing from this list.
+  std::vector<const EditTracker*> all_edit_trackers{
+      field_decl_rewriter.edit_tracker(),
+      var_decl_rewriter.edit_tracker(),
+      enum_member_decl_rewriter.edit_tracker(),
+      member_rewriter.edit_tracker(),
+      decl_ref_rewriter.edit_tracker(),
+      enum_member_ref_rewriter.edit_tracker(),
+      member_ref_rewriter.edit_tracker(),
+      function_decl_rewriter.edit_tracker(),
+      function_ref_rewriter.edit_tracker(),
+      method_decl_rewriter.edit_tracker(),
+      method_ref_rewriter.edit_tracker(),
+      method_member_rewriter.edit_tracker(),
+      constructor_initializer_rewriter.edit_tracker(),
+      unresolved_lookup_rewriter.edit_tracker(),
+      unresolved_member_rewriter.edit_tracker(),
+      unresolved_dependent_member_rewriter.edit_tracker(),
+      unresolved_using_value_decl_rewriter.edit_tracker(),
+      using_decl_rewriter.edit_tracker(),
+      dependent_scope_decl_ref_expr_rewriter.edit_tracker(),
+      cxx_dependent_scope_member_expr_rewriter.edit_tracker(),
+      gmock_member_rewriter.edit_tracker(),
+  };
   llvm::outs() << "==== BEGIN TRACKED EDITS ====\n";
-  field_decl_rewriter.edit_tracker().SerializeTo("var", llvm::outs());
-  var_decl_rewriter.edit_tracker().SerializeTo("var", llvm::outs());
-  enum_member_decl_rewriter.edit_tracker().SerializeTo("enu", llvm::outs());
-  function_decl_rewriter.edit_tracker().SerializeTo("fun", llvm::outs());
-  method_decl_rewriter.edit_tracker().SerializeTo("fun", llvm::outs());
+  for (const EditTracker* edit_tracker : all_edit_trackers)
+    edit_tracker->SerializeTo(llvm::outs());
   llvm::outs() << "==== END TRACKED EDITS ====\n";
 
   // Serialization format is documented in tools/clang/scripts/run_tool.py
   llvm::outs() << "==== BEGIN EDITS ====\n";
   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;
 }