clang: Add a tool for MessageLoop refactoring

tools/clang/refactor_message_loop/RefactorMessageLoop.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.
+//
+// This tool performs the following transformations on base::MessageLoop and
+// related APIs:
+//
+// MessageLoop:
+// - base::MessageLoop::PostTask*
+//   => base::MessageLoop::task_runner()->PostTask*()
+//
+// Thread:
+// - base::Thread::message_loop_proxy()
+//   => task_runner()
+//
+// MessageLoopProxy:
+// - base::MessageLoopProxy
+//   => base::SingleThreadTaskRunner
+// - scoped_refptr<base::MessageLoopProxy>
+//   => scoped_refptr<base::SingleThreadTaskRunner>
+// - base::MessageLoopProxy::current()
+//   => base::ThreadTaskRunnerHandle::Get()
+// - base::MessageLoop::message_loop_proxy()
+//   => base::MessageLoop::task_runner() (done)
+//
+// Additionally, the tool renames variables of type MessageLoopProxy* or
+// scoped_refptr<MessageLoopProxy> as follows:
+// - *message_loop_proxy* => *task_runner*
+// - *message_loop* => *task_runner*
+// - *loop_proxy* => *task_runner*
+// - *proxy* => *task_runner*
+// - *loop* => *task_runner*
+//
+
+#include <memory>
+#include "clang/AST/ExprCXX.h"
+#include "clang/ASTMatchers/ASTMatchers.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/Basic/SourceManager.h"
+#include "clang/Frontend/FrontendActions.h"
+#include "clang/Lex/Lexer.h"
+#include "clang/Tooling/CommonOptionsParser.h"
+#include "clang/Tooling/Refactoring.h"
+#include "clang/Tooling/Tooling.h"
+#include "llvm/Support/CommandLine.h"
+
+using clang::ast_matchers::MatchFinder;
+using clang::ast_matchers::anyOf;
+using clang::ast_matchers::asString;
+using clang::ast_matchers::callExpr;
+using clang::ast_matchers::callee;
+using clang::ast_matchers::constructExpr;
+using clang::ast_matchers::ctorInitializer;
+using clang::ast_matchers::decl;
+using clang::ast_matchers::declRefExpr;
+using clang::ast_matchers::expr;
+using clang::ast_matchers::fieldDecl;
+using clang::ast_matchers::functionDecl;
+using clang::ast_matchers::hasAncestor;
+using clang::ast_matchers::hasAnyTemplateArgument;
+using clang::ast_matchers::hasDescendant;
+using clang::ast_matchers::hasName;
+using clang::ast_matchers::hasType;
+using clang::ast_matchers::isSameOrDerivedFrom;
+using clang::ast_matchers::isTemplateInstantiation;
+using clang::ast_matchers::memberCallExpr;
+using clang::ast_matchers::memberExpr;
+using clang::ast_matchers::methodDecl;
+using clang::ast_matchers::ofClass;
+using clang::ast_matchers::pointsTo;
+using clang::ast_matchers::recordDecl;
+using clang::ast_matchers::references;
+using clang::ast_matchers::refersToType;
+using clang::ast_matchers::returns;
+using clang::ast_matchers::templateSpecializationType;
+using clang::ast_matchers::thisPointerType;
+using clang::ast_matchers::unless;
+using clang::ast_matchers::varDecl;
+using clang::ast_matchers::constructorDecl;
+using clang::ast_matchers::forEachConstructorInitializer;
+
+using clang::tooling::CommonOptionsParser;
+using clang::tooling::Replacement;
+using clang::tooling::Replacements;
+
+using clang::CXXMethodDecl;
+using clang::CXXMemberCallExpr;
+using clang::CXXCtorInitializer;
+using clang::CallExpr;
+using clang::Expr;
+using clang::DeclRefExpr;
+using clang::FieldDecl;
+using clang::MemberExpr;
+using clang::VarDecl;
+
+namespace {
+
+std::string ReplaceFirst(const std::string& input,
+                         const char* from,
+                         const char* to) {
+  size_t pos = input.find(from);
+  if (pos == std::string::npos)
+    return input;
+  return input.substr(0, pos) + to + input.substr(pos + strlen(from));
+}
+
+std::string RenameMessageLoopProxyVariable(std::string name) {
+  name = ReplaceFirst(name, "message_loop_proxy", "task_runner");
+  name = ReplaceFirst(name, "message_loop", "task_runner");
+  name = ReplaceFirst(name, "loop_proxy", "task_runner");
+  name = ReplaceFirst(name, "proxy", "task_runner");
+  name = ReplaceFirst(name, "loop", "task_runner");
+  return name;
+}
+
+// Handles conversion of the Post*Task APIs.
+class PostTaskCallback : public MatchFinder::MatchCallback {
+ public:
+  PostTaskCallback(Replacements* replacements) : replacements_(replacements) {}
+
+  virtual void run(const MatchFinder::MatchResult& result) override;
+
+ private:
+  Replacements* const replacements_;
+};
+
+// Refactors base::MessageLoopProxy::current() callers.
+class CurrentProxyCallback : public MatchFinder::MatchCallback {
+ public:
+  CurrentProxyCallback(Replacements* replacements)
+      : replacements_(replacements) {}
+
+  virtual void run(const MatchFinder::MatchResult& result) override;
+
+ private:
+  Replacements* const replacements_;
+};
+
+// Refactors callers to base::MessageLoop::message_loop_proxy() and
+// base::Thread::message_loop_proxy().
+class ProxyGetterCallback : public MatchFinder::MatchCallback {
+ public:
+  ProxyGetterCallback(Replacements* replacements)
+      : replacements_(replacements) {}
+
+  virtual void run(const MatchFinder::MatchResult& result) override;
+
+ private:
+  Replacements* const replacements_;
+};
+
+// Rewrites variables of type MessageLoopProxy*.
+class ProxyVariableCallback : public MatchFinder::MatchCallback {
+ public:
+  ProxyVariableCallback(Replacements* replacements)
+      : replacements_(replacements) {}
+
+  virtual void run(const MatchFinder::MatchResult& result) override;
+
+ private:
+  Replacements* const replacements_;
+};
+
+// Rewrites variables of type scoped_refptr<MessageLoopProxy>.
+class RefPtrProxyVariableCallback : public MatchFinder::MatchCallback {
+ public:
+  RefPtrProxyVariableCallback(Replacements* replacements)
+      : replacements_(replacements) {}
+
+  virtual void run(const MatchFinder::MatchResult& result) override;
+
+ private:
+  Replacements* const replacements_;
+};
+
+// Rewrites expressions of type MessageLoopProxy*.
+class ProxyExprCallback : public MatchFinder::MatchCallback {
+ public:
+  ProxyExprCallback(Replacements* replacements) : replacements_(replacements) {}
+
+  virtual void run(const MatchFinder::MatchResult& result) override;
+
+ private:
+  Replacements* const replacements_;
+};
+
+// Rewrites generic expressions involving MessageLoopProxy* or
+// scoped_refptr<MessageLoopProxy>.
+class GenericProxyExprCallback : public MatchFinder::MatchCallback {
+ public:
+  GenericProxyExprCallback(Replacements* replacements)
+      : replacements_(replacements) {}
+
+  virtual void run(const MatchFinder::MatchResult& result) override;
+
+ private:
+  Replacements* const replacements_;
+};
+
+// Rewrites functions that return scoped_refptr<base::MessageLoopProxy>.
+class CustomProxyGetterCallback : public MatchFinder::MatchCallback {
+ public:
+  CustomProxyGetterCallback(Replacements* replacements)
+      : replacements_(replacements) {}
+
+  virtual void run(const MatchFinder::MatchResult& result) override;
+
+ private:
+  Replacements* const replacements_;
+};
+
+class MessageLoopRefactorer {
+ public:
+  explicit MessageLoopRefactorer(Replacements* replacements)
+      : post_callback_(replacements),
+        current_proxy_callback_(replacements),
+        proxy_getter_callback_(replacements),
+        proxy_variable_callback_(replacements),
+        proxy_expr_callback_(replacements),
+        generic_proxy_expr_callback_(replacements),
+        refptr_proxy_variable_callback_(replacements),
+        custom_proxy_getter_callback_(replacements) {}
+
+  void SetupMatchers(MatchFinder* match_finder);
+
+ private:
+  PostTaskCallback post_callback_;
+  CurrentProxyCallback current_proxy_callback_;
+  ProxyGetterCallback proxy_getter_callback_;
+  ProxyVariableCallback proxy_variable_callback_;
+  ProxyExprCallback proxy_expr_callback_;
+  GenericProxyExprCallback generic_proxy_expr_callback_;
+  RefPtrProxyVariableCallback refptr_proxy_variable_callback_;
+  CustomProxyGetterCallback custom_proxy_getter_callback_;
+};
+
+void MessageLoopRefactorer::SetupMatchers(MatchFinder* match_finder) {
+  auto is_message_loop = recordDecl(isSameOrDerivedFrom("base::MessageLoop"));
+  auto is_thread = recordDecl(isSameOrDerivedFrom("base::Thread"));
+  auto is_message_loop_proxy =
+      recordDecl(isSameOrDerivedFrom("base::MessageLoopProxy"));
+
+  // Matches calls to the Post*Task APIs.
+  auto post_matcher =
+      memberCallExpr(thisPointerType(is_message_loop),
+                     callee(methodDecl(anyOf(
+                         hasName("PostTask"), hasName("PostDelayedTask"),
+                         hasName("PostNonNestableTask"),
+                         hasName("PostNonNestableDelayedTask"))))).bind("call");
+
+  // Matches calls to MessageLoopProxy::current().
+  auto current_proxy_matcher =
+      callExpr(callee(methodDecl(ofClass(is_message_loop_proxy),
+                                 hasName("current")))).bind("call");
+
+  auto message_loop_proxy_callee =
+      callee(methodDecl(hasName("message_loop_proxy")));
+
+  // Matches calls to MessageLoop::message_loop_proxy().
+  auto loop_proxy_getter_matcher =
+      memberCallExpr(thisPointerType(is_message_loop),
+                     message_loop_proxy_callee).bind("call");
+
+  // Matches calls to Thread::message_loop_proxy().
+  auto thread_proxy_getter_matcher =
+      memberCallExpr(thisPointerType(is_thread), message_loop_proxy_callee)
+          .bind("call");
+
+  // Matches variables and members pointing to a MessageLoopProxy that aren't
+  // inside template instantiations (e.g., scoped_retpr<>).
+  auto proxy_variable_matcher =
+      varDecl(hasType(pointsTo(recordDecl(hasName("base::MessageLoopProxy")))),
+              unless(hasAncestor(decl(anyOf(
+                  recordDecl(isTemplateInstantiation()),
+                  functionDecl(isTemplateInstantiation())))))).bind("var");
+  auto proxy_field_matcher =
+      fieldDecl(
+          hasType(pointsTo(recordDecl(hasName("base::MessageLoopProxy")))),
+          unless(hasAncestor(decl(
+              anyOf(recordDecl(isTemplateInstantiation()),
+                    functionDecl(isTemplateInstantiation())))))).bind("field");
+
+  // Matches any expressions that evaluate to base::MessageLoopProxy* but
+  // aren't result from a member or function call (e.g.,
+  // MessageLoopProxy::current()).
+  auto proxy_expr_matcher =
+      expr(hasType(pointsTo(recordDecl(hasName("base::MessageLoopProxy")))),
+           unless(anyOf(hasDescendant(callExpr()),
+                        hasDescendant(memberCallExpr())))).bind("expr");
+
+  // Matches methods which return or MessageLoopProxy* scoped_refptr<*>.
+  auto proxy_method_matcher =
+      methodDecl(
+          returns(pointsTo(recordDecl(hasName("base::MessageLoopProxy")))))
+          .bind("method");
+  auto refptr_proxy_method_matcher =
+      methodDecl(returns(asString("scoped_refptr<base::MessageLoopProxy>")))
+          .bind("method");
+
+  // Matches scoped_refptr<*> variable and member declarations. Note that
+  // further matching is done in the replacement to only target
+  // scoped_refptr<base::MessageLoopProxy>.
+  auto refptr_proxy_field_matcher =
+      fieldDecl(hasType(recordDecl(hasName("::scoped_refptr")))).bind("field");
+  auto refptr_proxy_variable_matcher =
+      varDecl(hasType(recordDecl(hasName("::scoped_refptr")))).bind("var");
+  auto refptr_proxy_ref_field_matcher =
+      fieldDecl(hasType(references(recordDecl(hasName("::scoped_refptr")))))
+          .bind("field");
+  auto refptr_proxy_ref_variable_matcher =
+      varDecl(hasType(references(recordDecl(hasName("::scoped_refptr")))))
+          .bind("var");
+
+  // The following three matchers are used to rename variables. They look for
+  // expressions, constructor initializers and declaration references (i.e.,
+  // constructor initializer parameters) of the type base::MessageLoopProxy* or
+  // any scoped_refptr<>. The actual matching to
+  // scoped_refptr<base::MessageLoopProxy> happens in the callback since I
+  // couldn't come up with a reliable AST matcher for doing that here.
+
+  // Matches scoped_refptr<> which is being passed as an argument to a
+  // function.
+  auto proxy_refptr_expr_matcher =
+      expr(hasType(recordDecl(hasName("::scoped_refptr"))),
+           anyOf(hasAncestor(callExpr()), hasAncestor(memberCallExpr())))
+          .bind("expr");
+
+  auto proxy_refptr_member_expr_matcher =
+      memberExpr(hasType(recordDecl(hasName("::scoped_refptr"))))
+          .bind("member");
+
+  // Matches any constructor initializer.
+  auto ctor_proxy_expr_matcher = constructorDecl(
+      forEachConstructorInitializer(ctorInitializer().bind("ctor")));
+
+  // Matches any declaration reference to a MessageLoopProxy* or
+  // scoped_refptr<>.
+  auto proxy_decl_ref_expr_matcher =
+      declRefExpr(anyOf(hasType(recordDecl(hasName("::scoped_refptr"))),
+                        hasType(pointsTo(recordDecl(
+                            hasName("base::MessageLoopProxy")))))).bind("ref");
+
+  match_finder->addMatcher(current_proxy_matcher, &current_proxy_callback_);
+  match_finder->addMatcher(loop_proxy_getter_matcher, &proxy_getter_callback_);
+  match_finder->addMatcher(thread_proxy_getter_matcher,
+                           &proxy_getter_callback_);
+  match_finder->addMatcher(post_matcher, &post_callback_);
+  match_finder->addMatcher(proxy_variable_matcher, &proxy_variable_callback_);
+  match_finder->addMatcher(proxy_field_matcher, &proxy_variable_callback_);
+  match_finder->addMatcher(refptr_proxy_field_matcher,
+                           &refptr_proxy_variable_callback_);
+  match_finder->addMatcher(refptr_proxy_variable_matcher,
+                           &refptr_proxy_variable_callback_);
+  match_finder->addMatcher(refptr_proxy_ref_field_matcher,
+                           &refptr_proxy_variable_callback_);
+  match_finder->addMatcher(refptr_proxy_ref_variable_matcher,
+                           &refptr_proxy_variable_callback_);
+  match_finder->addMatcher(proxy_expr_matcher, &proxy_expr_callback_);
+
+  match_finder->addMatcher(proxy_refptr_expr_matcher,
+                           &generic_proxy_expr_callback_);
+  match_finder->addMatcher(ctor_proxy_expr_matcher,
+                           &generic_proxy_expr_callback_);
+  match_finder->addMatcher(proxy_decl_ref_expr_matcher,
+                           &generic_proxy_expr_callback_);
+  match_finder->addMatcher(proxy_refptr_member_expr_matcher,
+                           &generic_proxy_expr_callback_);
+
+  match_finder->addMatcher(proxy_method_matcher,
+                           &custom_proxy_getter_callback_);
+  match_finder->addMatcher(refptr_proxy_method_matcher,
+                           &custom_proxy_getter_callback_);
+}
+
+void PostTaskCallback::run(const MatchFinder::MatchResult& result) {
+  const CXXMemberCallExpr* call =
+      result.Nodes.getNodeAs<CXXMemberCallExpr>("call");
+  const Expr* obj = call->getImplicitObjectArgument();
+  const MemberExpr* callee = clang::dyn_cast<MemberExpr>(call->getCallee());
+
+  clang::CharSourceRange range =
+      clang::CharSourceRange::getTokenRange(callee->getSourceRange());
+  clang::CharSourceRange obj_range =
+      clang::CharSourceRange::getTokenRange(obj->getSourceRange());
+
+  std::string text = clang::Lexer::getSourceText(range, *result.SourceManager,
+                                                 result.Context->getLangOpts());
+  std::string obj_text = clang::Lexer::getSourceText(
+      obj_range, *result.SourceManager, result.Context->getLangOpts());
+  std::string method = call->getMethodDecl()->getNameInfo().getAsString();
+
+  // Rewrite the call to go through the task runner.
+  bool is_arrow = callee->isArrow();
+  std::string replacement =
+      obj_text + (is_arrow ? "->" : ".") + "task_runner()->" + method;
+
+  // Rewrite MessageLoop::current() as ThreadTaskRunnerHandle::Get().
+  if (obj_text.find("MessageLoop::current") != obj_text.npos ||
+      obj_text.find("MessageLoopForIO::current") != obj_text.npos ||
+      obj_text.find("MessageLoopForUI::current") != obj_text.npos) {
+    std::string ns = "";
+    if (obj_text.find("base::") == 0) {
+      ns = "base::";
+    }
+    replacement = ns + "ThreadTaskRunnerHandle::Get()->" + method;
+  }
+
+  replacements_->insert(Replacement(*result.SourceManager, range, replacement));
+}
+
+void CurrentProxyCallback::run(const MatchFinder::MatchResult& result) {
+  const CallExpr* call = result.Nodes.getNodeAs<CallExpr>("call");
+  clang::CharSourceRange range =
+      clang::CharSourceRange::getTokenRange(call->getSourceRange());
+  std::string text = clang::Lexer::getSourceText(range, *result.SourceManager,
+                                                 result.Context->getLangOpts());
+
+  std::string ns = "";
+  if (text.find("base::") == 0) {
+    ns = "base::";
+  }
+  std::string replacement = ns + "ThreadTaskRunnerHandle::Get()";
+  replacements_->insert(Replacement(*result.SourceManager, range, replacement));
+}
+
+void ProxyGetterCallback::run(const MatchFinder::MatchResult& result) {
+  const CXXMemberCallExpr* call =
+      result.Nodes.getNodeAs<CXXMemberCallExpr>("call");
+  const MemberExpr* callee = clang::dyn_cast<MemberExpr>(call->getCallee());
+  clang::CharSourceRange range =
+      clang::CharSourceRange::getTokenRange(callee->getSourceRange());
+
+  std::string text = clang::Lexer::getSourceText(range, *result.SourceManager,
+                                                 result.Context->getLangOpts());
+
+  text = ReplaceFirst(text, "message_loop_proxy", "task_runner");
+  replacements_->insert(Replacement(*result.SourceManager, range, text));
+}
+
+void ProxyVariableCallback::run(const MatchFinder::MatchResult& result) {
+  const VarDecl* var = result.Nodes.getNodeAs<VarDecl>("var");
+  const FieldDecl* field = result.Nodes.getNodeAs<FieldDecl>("field");
+  clang::CharSourceRange range = clang::CharSourceRange::getTokenRange(
+      var ? var->getSourceRange() : field->getSourceRange());
+
+  std::string text = clang::Lexer::getSourceText(range, *result.SourceManager,
+                                                 result.Context->getLangOpts());
+
+  // Change the type of the pointee.
+  text = ReplaceFirst(text, "MessageLoopProxy", "SingleThreadTaskRunner");
+
+  // Rename the pointer variable too.
+  text = RenameMessageLoopProxyVariable(text);
+
+  replacements_->insert(Replacement(*result.SourceManager, range, text));
+}
+
+void RefPtrProxyVariableCallback::run(const MatchFinder::MatchResult& result) {
+  const VarDecl* var = result.Nodes.getNodeAs<VarDecl>("var");
+  const FieldDecl* field = result.Nodes.getNodeAs<FieldDecl>("field");
+  clang::CharSourceRange range = clang::CharSourceRange::getTokenRange(
+      var ? var->getSourceRange() : field->getSourceRange());
+
+  std::string text = clang::Lexer::getSourceText(range, *result.SourceManager,
+                                                 result.Context->getLangOpts());
+  if (text.find("MessageLoopProxy") == text.npos)
+    return;
+
+  // Change the type of the pointee.
+  text = ReplaceFirst(text, "MessageLoopProxy", "SingleThreadTaskRunner");
+
+  // Rename the refptr variable too.
+  text = RenameMessageLoopProxyVariable(text);
+
+  replacements_->insert(Replacement(*result.SourceManager, range, text));
+}
+
+void ProxyExprCallback::run(const MatchFinder::MatchResult& result) {
+  const Expr* expr = result.Nodes.getNodeAs<Expr>("expr");
+  clang::CharSourceRange range =
+      clang::CharSourceRange::getTokenRange(expr->getSourceRange());
+
+  std::string text = clang::Lexer::getSourceText(range, *result.SourceManager,
+                                                 result.Context->getLangOpts());
+
+  std::string replacement = RenameMessageLoopProxyVariable(text);
+  if (replacement != text) {
+    replacements_->insert(
+        Replacement(*result.SourceManager, range, replacement));
+  }
+}
+
+void GenericProxyExprCallback::run(const MatchFinder::MatchResult& result) {
+  const Expr* expr = result.Nodes.getNodeAs<Expr>("expr");
+  const CXXCtorInitializer* ctor =
+      result.Nodes.getNodeAs<CXXCtorInitializer>("ctor");
+  const DeclRefExpr* ref = result.Nodes.getNodeAs<DeclRefExpr>("ref");
+  const MemberExpr* member = result.Nodes.getNodeAs<MemberExpr>("member");
+  clang::CharSourceRange range = clang::CharSourceRange::getTokenRange(
+      expr ? expr->getSourceRange() : ref ? ref->getSourceRange()
+                                          : member ? member->getSourceRange()
+                                                   : ctor->getSourceRange());
+
+  std::string type;
+  if (expr) {
+    type = expr->getType().getAsString();
+  } else if (ref) {
+    type = ref->getType().getAsString();
+  } else if (member) {
+    type = member->getType().getAsString();
+  } else {
+    // Ignore base class constructors.
+    if (!ctor->getMember())
+      return;
+    type = ctor->getMember()->getType().getAsString();
+  }
+
+  // Ignore unrelated scoped_refptr<>s.
+  if (type.find("scoped_refptr<base::MessageLoopProxy>") == type.npos &&
+      type.find("base::MessageLoopProxy *") == type.npos)
+    return;
+
+  std::string text = clang::Lexer::getSourceText(range, *result.SourceManager,
+                                                 result.Context->getLangOpts());
+  std::string replacement = RenameMessageLoopProxyVariable(text);
+
+  // For field initializers, also try renaming the initializing value.
+  if (ctor) {
+    replacement = RenameMessageLoopProxyVariable(replacement);
+    // Hack: rename any static getter because the renaming of the field will
+    // conflict the edit that replaces the getter.
+    replacement = ReplaceFirst(replacement, "base::MessageLoopProxy::current()",
+                               "base::ThreadTaskRunnerHandle::Get()");
+  }
+
+  if (replacement != text) {
+    replacements_->insert(
+        Replacement(*result.SourceManager, range, replacement));
+  }
+}
+
+void CustomProxyGetterCallback::run(const MatchFinder::MatchResult& result) {
+  const CXXMethodDecl* method = result.Nodes.getNodeAs<CXXMethodDecl>("method");
+  clang::CharSourceRange range =
+      clang::CharSourceRange::getTokenRange(method->getReturnTypeSourceRange());
+  std::string text = clang::Lexer::getSourceText(range, *result.SourceManager,
+                                                 result.Context->getLangOpts());
+
+  std::string replacement =
+      ReplaceFirst(text, "MessageLoopProxy", "SingleThreadTaskRunner");
+  if (replacement != text) {
+    replacements_->insert(
+        Replacement(*result.SourceManager, range, replacement));
+  }
+}
+
+}  // namespace
+
+static llvm::cl::extrahelp common_help(CommonOptionsParser::HelpMessage);
+
+int main(int argc, const char* argv[]) {
+  llvm::cl::OptionCategory category("MessageLoop refactoring tool");
+  CommonOptionsParser options(argc, argv, category);
+  clang::tooling::ClangTool tool(options.getCompilations(),
+                                 options.getSourcePathList());
+
+  Replacements replacements;
+  MessageLoopRefactorer refactorer(&replacements);
+  MatchFinder match_finder;
+  refactorer.SetupMatchers(&match_finder);
+
+  std::unique_ptr<clang::tooling::FrontendActionFactory> frontend_factory =
+      clang::tooling::newFrontendActionFactory(&match_finder);
+  int result = tool.run(frontend_factory.get());
+  if (result != 0)
+    return result;
+
+  // Each replacement line should have the following format:
+  // r:<file path>:<offset>:<length>:<replacement text>
+  // Only the <replacement text> field can contain embedded ":" characters.
+  // TODO(dcheng): Use a more clever serialization. Ideally we'd use the YAML
+  // serialization and then use clang-apply-replacements, but that would require
+  // copying and pasting a larger amount of boilerplate for all Chrome clang
+  // tools.
+  llvm::outs() << "==== BEGIN EDITS ====\n";
+  unsigned prev_end = 0;
+  for (const auto& r : replacements) {
+    // Discard overlapping edits.
+    if (prev_end > r.getOffset())

[dcheng, 2015/05/06 17:31:18]

Are you actually generating overlapping edits, or identical ones?

[Sami, 2015/05/07 10:37:37]

They are identical in the sense that the end result is the same but different
parts of the edit can be generated by different rules.

IIRC for example in some contexts "scoped_refptr<base::MessageLoopProxy> proxy"
is first rewritten to "scoped_refptr<base::SingleThreadTaskRunner> task_runner"
and then a further rule would try to rewrite "proxy" into "task_runner" but
would fail because the first edit changed the offset.

Maybe a cleaner way to do that would be to split this into two tools -- one for
rewriting classes and another for rewriting variables.

[dcheng, 2015/05/26 20:35:44]

I'm really surprised that you need to do this. The rewrite that you're
describing should be OK: _ApplyEdits() in the script tries to apply the edits in
reverse order. So proxy should be rewritten to task_runner first, and then the
scoped_refptr<> parameter should get rewritten after that. This should prevent
edits from conflicting...

If this is a bug in run_tools.py, it seems like we should try to fix that.

+      continue;
+    prev_end = r.getOffset() + r.getLength();
+    llvm::outs() << "r:::" << r.getFilePath() << ":::" << r.getOffset()
+                 << ":::" << r.getLength() << ":::" << r.getReplacementText()
+                 << "\n";
+  }
+  llvm::outs() << "==== END EDITS ====\n";
+
+  return 0;
+}