--method-blocklist should also cover free functions.

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 112 matching lines @@
   return false;
 }
 
 class MethodBlocklist {
  public:
   explicit MethodBlocklist(const std::string& filepath) {
     if (!filepath.empty())
       ParseInputFile(filepath);
   }
 
-  bool Contains(const clang::CXXMethodDecl& method) const {
+  bool Contains(const clang::FunctionDecl& method) const {
     auto it = method_to_class_to_args_.find(method.getName());
     if (it == method_to_class_to_args_.end())
       return false;
 
-    const clang::CXXRecordDecl* actual_class = method.getParent();
-    assert(actual_class &&
-           "Hopefully |getParent()| can find the class even for non-inlined "
-           "method definitions (where CXXRecordDecl is not a parent AST node "
-           "of CXXMethodDecl.");
+    // |method_context| is either
+    // 1) a CXXRecordDecl (i.e. blink::Document) or
+    // 2) a NamespaceDecl (i.e. blink::DOMWindowTimers).
+    const clang::NamedDecl* method_context =
+        clang::dyn_cast<clang::NamedDecl>(method.getDeclContext());
+    if (!method_context)
+      return false;
 
     const llvm::StringMap<std::set<unsigned>>& class_to_args = it->second;
-    auto it2 = class_to_args.find(actual_class->getName());
+    auto it2 = class_to_args.find(method_context->getName());
     if (it2 == class_to_args.end())
       return false;
 
     const std::set<unsigned>& arg_counts = it2->second;
     unsigned method_param_count = method.param_size();
     unsigned method_non_optional_param_count = method_param_count;
     for (const clang::ParmVarDecl* param : method.parameters()) {
       if (param->hasInit())
         method_non_optional_param_count--;
     }
@@ skipping 62 matching lines @@
       method_to_class_to_args_[method_name][class_name].insert(
           number_of_method_args);
     }
   }
 
   // Stores methods to blacklist in a map:
   // method name -> class name -> set of all allowed numbers of arguments.
   llvm::StringMap<llvm::StringMap<std::set<unsigned>>> method_to_class_to_args_;
 };
 
-AST_MATCHER_P(clang::CXXMethodDecl,
+AST_MATCHER_P(clang::FunctionDecl,
               isBlocklistedMethod,
               MethodBlocklist,
               Blocklist) {
   return Blocklist.Contains(Node);
 }
 
 // If |InnerMatcher| matches |top|, then the returned matcher will match:
 // - |top::function|
 // - |top::Class::method|
 // - |top::internal::Class::method|
@@ skipping 1146 matching lines @@
   // TODO(dcheng): Clang tooling should do this itself.
   // http://llvm.org/bugs/show_bug.cgi?id=21627
   llvm::InitializeNativeTarget();
   llvm::InitializeNativeTargetAsmParser();
   llvm::cl::OptionCategory category(
       "rewrite_to_chrome_style: convert Blink style to Chrome style.");
   llvm::cl::opt<std::string> blocklisted_methods_file(
       kMethodBlocklistParamName, llvm::cl::value_desc("filepath"),
       llvm::cl::desc("file listing methods to be blocked (not renamed)"));
   CommonOptionsParser options(argc, argv, category);
+  MethodBlocklist method_blocklist(blocklisted_methods_file);
   clang::tooling::ClangTool tool(options.getCompilations(),
                                  options.getSourcePathList());
 
   MatchFinder match_finder;
   std::set<Replacement> replacements;
 
   // Blink namespace matchers ========
   auto blink_namespace_decl =
       namespaceDecl(anyOf(hasName("blink"), hasName("WTF")),
                     hasParent(translationUnitDecl()));
@@ skipping 101 matching lines @@
       "decl",
       functionDecl(
           unless(anyOf(
               // Methods are covered by the method matchers.
               cxxMethodDecl(),
               // Out-of-line overloaded operators have special names and should
               // never be renamed.
               isOverloadedOperator(),
               // Must be checked after filtering out overloaded operators to
               // prevent asserts about the identifier not being a simple name.
-              isBlacklistedFunction())),
+              isBlacklistedFunction(),
+              // Functions that look like blocked static methods.
+              isBlocklistedMethod(method_blocklist))),
           in_blink_namespace));
   FunctionDeclRewriter function_decl_rewriter(&replacements);
   match_finder.addMatcher(function_decl_matcher, &function_decl_rewriter);
 
   // Non-method function references ========
   // Given
   //   f();
   //   void (*p)() = &f;
   // matches |f()| and |&f|.
   auto function_ref_matcher = id(
       "expr", declRefExpr(to(function_decl_matcher),
                           // Ignore template substitutions.
                           unless(hasAncestor(substNonTypeTemplateParmExpr()))));
   FunctionRefRewriter function_ref_rewriter(&replacements);
   match_finder.addMatcher(function_ref_matcher, &function_ref_rewriter);
 
   // Method declarations ========
   // Given
   //   struct S {
   //     void g();
   //   };
   // matches |g|.
   // For a method to be considered for rewrite, it must not override something
   // that we're not rewriting. Any methods that we would not normally consider
   // but that override something we are rewriting should also be rewritten. So
   // we use includeAllOverriddenMethods() to check these rules not just for the
   // method being matched but for the methods it overrides also.
-  MethodBlocklist method_blocklist(blocklisted_methods_file);
   auto is_blink_method = includeAllOverriddenMethods(
-      allOf(in_blink_namespace, unless(isBlacklistedMethod()),
-            unless(isBlocklistedMethod(method_blocklist))));
+      allOf(in_blink_namespace,
+            unless(anyOf(isBlacklistedMethod(),
+                         isBlocklistedMethod(method_blocklist)))));
   auto method_decl_matcher = id(
       "decl",
       cxxMethodDecl(
           unless(anyOf(
               // Overloaded operators have special names and should never be
               // renamed.
               isOverloadedOperator(),
               // Similarly, constructors, destructors, and conversion
               // functions should not be considered for renaming.
               cxxConstructorDecl(), cxxDestructorDecl(), cxxConversionDecl())),
@@ skipping 227 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;
 }