rewrite_to_chrome_style: Improve naming of iterator and type traits.

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 56 matching lines @@
   return Node.isOverloadedOperator();
 }
 
 AST_MATCHER_P(clang::FunctionTemplateDecl,
               templatedDecl,
               clang::ast_matchers::internal::Matcher<clang::FunctionDecl>,
               InnerMatcher) {
   return InnerMatcher.matches(*Node.getTemplatedDecl(), Finder, Builder);
 }
 
+bool IsDeclContextInBlinkOrWTF(const clang::DeclContext* decl_context,
+                               bool blink,
+                               bool wtf) {
+  assert(blink || wtf);  // Else, what's the point?
+  auto* namespace_decl = clang::dyn_cast_or_null<clang::NamespaceDecl>(
+      decl_context->getEnclosingNamespaceContext());
+  return namespace_decl && namespace_decl->getParent()->isTranslationUnit() &&
+         ((blink && namespace_decl->getName() == "blink") ||
+          (wtf && namespace_decl->getName() == "WTF"));
+}
+
 // A method is from Blink if it is from the Blink namespace or overrides a
 // method from the Blink namespace.
-bool IsBlinkMethod(const clang::CXXMethodDecl& decl) {
-  auto* namespace_decl = clang::dyn_cast_or_null<clang::NamespaceDecl>(
-      decl.getParent()->getEnclosingNamespaceContext());
-  if (namespace_decl && namespace_decl->getParent()->isTranslationUnit() &&
-      (namespace_decl->getName() == "blink" ||
-       namespace_decl->getName() == "WTF"))
+bool IsBlinkOrWTFMethod(const clang::CXXMethodDecl& decl) {
+  if (IsDeclContextInBlinkOrWTF(decl.getDeclContext(), true, true))
     return true;
 
   for (auto it = decl.begin_overridden_methods();
        it != decl.end_overridden_methods(); ++it) {
-    if (IsBlinkMethod(**it))
+    if (IsBlinkOrWTFMethod(**it))
       return true;
   }
   return false;
 }
 
-AST_MATCHER(clang::CXXMethodDecl, isBlinkMethod) {
-  return IsBlinkMethod(Node);
+AST_MATCHER(clang::CXXMethodDecl, isBlinkOrWTFMethod) {
+  return IsBlinkOrWTFMethod(Node);
 }
 
 // Helper to convert from a camelCaseName to camel_case_name. It uses some
 // heuristics to try to handle acronyms in camel case names correctly.
 std::string CamelCaseToUnderscoreCase(StringRef input,
                                       bool numbers_are_separated) {
   std::string output;
   bool needs_underscore = false;
   bool was_lowercase = false;
   bool was_number = false;
@@ skipping 106 matching lines @@
     c = clang::toUppercase(c);
   return true;
 }
 
 bool GetNameForDecl(const clang::CXXMethodDecl& decl,
                     const clang::ASTContext& context,
                     std::string& name) {
   StringRef original_name = decl.getName();
 
   if (!decl.isStatic()) {
+    std::string ret_type = decl.getReturnType().getAsString();
+    if (ret_type.find("iterator") != std::string::npos ||
+        ret_type.find("Iterator") != std::string::npos) {
+      // Iterator methods shouldn't be renamed to work with stl and range-for
+      // loops.
+      static const char* kIteratorBlacklist[] = {"begin", "end", "rbegin",
+                                                 "rend"};
+      for (const auto& b : kIteratorBlacklist) {
+        if (original_name == b)
+          return false;
+      }
+    }
+
     // Some methods shouldn't be renamed because reasons.
-    static const char* kBlacklist[] = {"begin", "end",  "rbegin", "rend",
-                                       "trace", "lock", "unlock", "try_lock"};
+    static const char* kBlacklist[] = {"trace", "lock", "unlock", "try_lock"};
     for (const auto& b : kBlacklist) {
       if (original_name == b)
         return false;
     }
   }
 
   name = decl.getName().str();
   name[0] = clang::toUppercase(name[0]);
   return true;
 }
@@ skipping 33 matching lines @@
     original_name = original_name.substr(strlen(kBlinkStaticMemberPrefix));
   else if (original_name.startswith(kBlinkFieldPrefix))
     original_name = original_name.substr(strlen(kBlinkFieldPrefix));
 
   bool is_const = IsProbablyConst(decl, context);
   if (is_const) {
     // Don't try to rename constants that already conform to Chrome style.
     if (original_name.size() >= 2 && original_name[0] == 'k' &&
         clang::isUppercase(original_name[1]))
       return false;
+
+    // Struct consts in WTF do not become kFoo cuz stuff like type traits
+    // should stay as lowercase.
+    const clang::DeclContext* decl_context = decl.getDeclContext();
+    bool is_in_wtf = IsDeclContextInBlinkOrWTF(decl_context, false, true);
+    const clang::CXXRecordDecl* parent =
+        clang::dyn_cast_or_null<clang::CXXRecordDecl>(decl_context);
+    if (is_in_wtf && parent && parent->isStruct())
+      return false;
+
     name = 'k';
     name.append(original_name.data(), original_name.size());
     name[1] = clang::toUppercase(name[1]);
   } else {
     name = CamelCaseToUnderscoreCase(original_name, false);
   }
 
   // Static members end with _ just like other members, but constants should
   // not.
   if (!is_const && decl.isStaticDataMember()) {
@@ skipping 257 matching lines @@
   match_finder.addMatcher(function_ref_matcher, &function_ref_rewriter);
 
   // Method declarations ========
   // Given
   //   struct S {
   //     void g();
   //   };
   // matches |g|.
   auto method_decl_matcher =
       id("decl",
-         cxxMethodDecl(isBlinkMethod(),
+         cxxMethodDecl(isBlinkOrWTFMethod(),
                        unless(anyOf(is_generated,
                                     // 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()))));
   MethodDeclRewriter method_decl_rewriter(&replacements);
@@ skipping 101 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;
 }