rewrite_to_chrome_style: improve template rewrite handling

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 38 matching lines @@
 namespace {
 
 const char kBlinkFieldPrefix[] = "m_";
 const char kBlinkStaticMemberPrefix[] = "s_";
 const char kGeneratedFileRegex[] = "^gen/|/gen/";
 
 const clang::ast_matchers::internal::
     VariadicDynCastAllOfMatcher<clang::Expr, clang::UnresolvedLookupExpr>
         unresolvedLookupExpr;
 
+const clang::ast_matchers::internal::
+    VariadicDynCastAllOfMatcher<clang::Expr, clang::UnresolvedMemberExpr>
+        unresolvedMemberExpr;
+
 AST_MATCHER(clang::FunctionDecl, isOverloadedOperator) {
   return Node.isOverloadedOperator();
 }
 
 AST_MATCHER_P(clang::FunctionTemplateDecl,
               templatedDecl,
               clang::ast_matchers::internal::Matcher<clang::FunctionDecl>,
               InnerMatcher) {
   return InnerMatcher.matches(*Node.getTemplatedDecl(), Finder, Builder);
 }
@@ skipping 390 matching lines @@
     assert(init.isWritten());
     return init.getSourceLocation();
   }
   static const char* GetName() { return "initializer"; }
   static const char* GetType() { return "CXXCtorInitializer"; }
 };
 
 template <>
 struct TargetNodeTraits<clang::UnresolvedLookupExpr> {
   static clang::SourceLocation GetLoc(const clang::UnresolvedLookupExpr& expr) {
-    return expr.getLocStart();
+    return expr.getNameLoc();
   }
   static const char* GetName() { return "expr"; }
   static const char* GetType() { return "UnresolvedLookupExpr"; }
 };
 
+template <>
+struct TargetNodeTraits<clang::UnresolvedMemberExpr> {
+  static clang::SourceLocation GetLoc(const clang::UnresolvedMemberExpr& expr) {
+    return expr.getMemberLoc();
+  }
+  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 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())
@@ skipping 54 matching lines @@
 using MethodMemberRewriter =
     RewriterBase<clang::CXXMethodDecl, clang::MemberExpr>;
 
 using EnumConstantDeclRewriter =
     RewriterBase<clang::EnumConstantDecl, clang::NamedDecl>;
 using EnumConstantDeclRefRewriter =
     RewriterBase<clang::EnumConstantDecl, clang::DeclRefExpr>;
 
 using UnresolvedLookupRewriter =
     RewriterBase<clang::NamedDecl, clang::UnresolvedLookupExpr>;
+using UnresolvedMemberRewriter =
+    RewriterBase<clang::NamedDecl, clang::UnresolvedMemberExpr>;
 
 using UsingDeclRewriter = RewriterBase<clang::UsingDecl, clang::NamedDecl>;
 
 }  // namespace
 
 static llvm::cl::extrahelp common_help(CommonOptionsParser::HelpMessage);
 
 int main(int argc, const char* argv[]) {
   // TODO(dcheng): Clang tooling should do this itself.
   // http://llvm.org/bugs/show_bug.cgi?id=21627
@@ skipping 206 matching lines @@
   //    selected until instantiation time either.
   //
   // Another instance where UnresolvedLookupExprs can appear is in a template
   // argument list, like the provided example.
   auto function_template_decl_matcher =
       id("decl", functionTemplateDecl(templatedDecl(function_decl_matcher)));
   auto method_template_decl_matcher =
       id("decl", functionTemplateDecl(templatedDecl(method_decl_matcher)));
   auto unresolved_lookup_matcher = expr(id(
       "expr",
-      unresolvedLookupExpr(anyOf(
+      unresolvedLookupExpr(
           // In order to automatically rename an unresolved lookup, the lookup
           // candidates must either all be Blink functions/function templates or
-          // Blink methods/method templates. Otherwise, we might end up in a
-          // situation where the naming could change depending on the selected
-          // candidate.
-          allOverloadsMatch(
-              anyOf(function_decl_matcher, function_template_decl_matcher)),
-          allOverloadsMatch(
-              anyOf(method_decl_matcher, method_template_decl_matcher))))));
+          // all be Blink methods/method templates. Otherwise, we might end up
+          // in a situation where the naming could change depending on the
+          // selected candidate.
+          anyOf(allOverloadsMatch(anyOf(function_decl_matcher,
+                                        function_template_decl_matcher)),
+                // Note: this matches references to methods in a non-member
+                // context, e.g. Template<&Class::Method>.

[danakj, 2016/03/28 18:35:10]

Can you say why this not using the UnresolvedMemberRewriter? It looks
unintentional

[dcheng, 2016/03/28 21:22:44]

Done.

+                allOverloadsMatch(anyOf(method_decl_matcher,
+                                        method_template_decl_matcher))))));
   UnresolvedLookupRewriter unresolved_lookup_rewriter(&replacements);
   match_finder.addMatcher(unresolved_lookup_matcher,
                           &unresolved_lookup_rewriter);
 
+  // Unresolved member expressions ========
+  // Similar to unresolved lookup expressions, but for methods in a member
+  // context, e.g. var_with_templated_type.Method().
+  auto unresolved_member_matcher = expr(id(
+      "expr",
+      unresolvedMemberExpr(
+          // Similar to UnresolvedLookupExprs, all the candidate methods must be
+          // Blink methods/method templates.
+          allOverloadsMatch(
+              anyOf(method_decl_matcher, method_template_decl_matcher)))));
+  UnresolvedMemberRewriter unresolved_member_rewriter(&replacements);
+  match_finder.addMatcher(unresolved_member_matcher,
+                          &unresolved_member_rewriter);
+
   // Using declarations ========
   // Given
   //   using blink::X;
   // matches |using blink::X|.
   auto using_decl_matcher = id(
       "decl", usingDecl(hasAnyUsingShadowDecl(hasTargetDecl(anyOf(
                   var_decl_matcher, field_decl_matcher, function_decl_matcher,
                   method_decl_matcher, function_template_decl_matcher,
                   method_template_decl_matcher, enum_member_decl_matcher)))));
   UsingDeclRewriter using_decl_rewriter(&replacements);
@@ skipping 43 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;
 }