Capitalize WTF-based type traits as lower_case

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 473 matching lines @@
 }
 
 AST_MATCHER(clang::FunctionDecl, isBlacklistedFunction) {
   return IsBlacklistedFunction(Node);
 }
 
 AST_MATCHER(clang::CXXMethodDecl, isBlacklistedMethod) {
   return IsBlacklistedMethod(Node);
 }
 
+bool IsKnownTraitName(clang::StringRef name) {
+  // This set of names is globally a type trait throughout chromium.
+  return name == "safeToCompareToEmptyOrDeleted";
+}
+
+AST_MATCHER(clang::VarDecl, isKnownTraitName) {
+  return IsKnownTraitName(Node.getName());
+}
+
 // 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) {
   std::string output;
   bool needs_underscore = false;
   bool was_lowercase = false;
   bool was_uppercase = false;
   bool first_char = true;
   // Iterate in reverse to minimize the amount of backtracking.
   for (const unsigned char* i = input.bytes_end() - 1; i >= input.bytes_begin();
@@ skipping 205 matching lines @@
 
   return false;
 }
 
 AST_MATCHER(clang::FunctionDecl, shouldPrefixFunctionName) {
   return ShouldPrefixFunctionName(Node.getName().str());
 }
 
 bool GetNameForDecl(const clang::FunctionDecl& decl,
                     clang::ASTContext& context,
+                    bool for_type_trait,
                     std::string& name) {
   name = decl.getName().str();
   name[0] = clang::toUppercase(name[0]);
 
   // Given
   //   class Foo {};
   //   class DerivedFoo : class Foo;
   //   using Bar = Foo;
   //   Bar f1();  // <- |Bar| would be matched by hasString("Bar") below.
   //   Bar f2();  // <- |Bar| would be matched by hasName("Foo") below.
@@ skipping 27 matching lines @@
       // And also check hardcoded list of function names to prefix with "Get".
       shouldPrefixFunctionName()));
   if (IsMatching(conflict_matcher, decl, context))
     name = "Get" + name;
 
   return true;
 }
 
 bool GetNameForDecl(const clang::EnumConstantDecl& decl,
                     clang::ASTContext& context,
+                    bool for_type_trait,
                     std::string& name) {
   StringRef original_name = decl.getName();
 
   // If it's already correct leave it alone.
   if (original_name.size() >= 2 && original_name[0] == 'k' &&
       clang::isUppercase(original_name[1]))
     return false;
 
   bool is_shouty = true;
   for (char c : original_name) {
     if (!clang::isUppercase(c) && !clang::isDigit(c) && c != '_') {
       is_shouty = false;
       break;
     }
   }
 
   if (is_shouty)
     return false;
 
   name = 'k';  // k prefix on enum values.
   name += original_name;
   name[1] = clang::toUppercase(name[1]);
   return true;
 }
 
 bool GetNameForDecl(const clang::FieldDecl& decl,
                     clang::ASTContext& context,
+                    bool for_type_trait,
                     std::string& name) {
   StringRef original_name = decl.getName();
   bool member_prefix = original_name.startswith(kBlinkFieldPrefix);
 
   StringRef rename_part = !member_prefix
                               ? original_name
                               : original_name.substr(strlen(kBlinkFieldPrefix));
   name = CamelCaseToUnderscoreCase(rename_part);
 
   // Assume that prefix of m_ was intentional and always replace it with a
   // suffix _.
   if (member_prefix && name.back() != '_')
     name += '_';
 
   return true;
 }
 
 bool GetNameForDecl(const clang::VarDecl& decl,
                     clang::ASTContext& context,
+                    bool for_type_trait,
                     std::string& name) {
   StringRef original_name = decl.getName();
 
   // Nothing to do for unnamed parameters.
   if (clang::isa<clang::ParmVarDecl>(decl)) {
     if (original_name.empty())
       return false;
 
     // Check if |decl| and |decl.getLocation| are in sync.  We need to skip
     // out-of-sync ParmVarDecls to avoid renaming buggy ParmVarDecls that
@@ skipping 15 matching lines @@
   }
 
   // static class members match against VarDecls. Blink style dictates that
   // these should be prefixed with `s_`, so strip that off. Also check for `m_`
   // and strip that off too, for code that accidentally uses the wrong prefix.
   if (original_name.startswith(kBlinkStaticMemberPrefix))
     original_name = original_name.substr(strlen(kBlinkStaticMemberPrefix));
   else if (original_name.startswith(kBlinkFieldPrefix))
     original_name = original_name.substr(strlen(kBlinkFieldPrefix));
 
+  // Type traits are written in_this_form rather than kInThisForm and not like
+  // members.
+  if (for_type_trait) {
+    name = CamelCaseToUnderscoreCase(original_name);
+    return true;
+  }
+
   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;
     // Or names are spelt with underscore casing. While they are actually
     // compile consts, the author wrote it explicitly as a variable not as
     // a constant (they would have used kFormat otherwise here), so preserve
     // it rather than try to mangle a kFormat out of it.
@@ skipping 18 matching lines @@
   // not.
   if (!is_const && decl.isStaticDataMember()) {
     name += '_';
   }
 
   return true;
 }
 
 bool GetNameForDecl(const clang::FunctionTemplateDecl& decl,
                     clang::ASTContext& context,
+                    bool for_type_trait,
                     std::string& name) {
   clang::FunctionDecl* templated_function = decl.getTemplatedDecl();
-  return GetNameForDecl(*templated_function, context, name);
+  return GetNameForDecl(*templated_function, context, for_type_trait, name);
 }
 
 bool GetNameForDecl(const clang::NamedDecl& decl,
                     clang::ASTContext& context,
+                    bool for_type_trait,
                     std::string& name) {
   if (auto* function = clang::dyn_cast<clang::FunctionDecl>(&decl))
-    return GetNameForDecl(*function, context, name);
+    return GetNameForDecl(*function, context, for_type_trait, name);
   if (auto* var = clang::dyn_cast<clang::VarDecl>(&decl))
-    return GetNameForDecl(*var, context, name);
+    return GetNameForDecl(*var, context, for_type_trait, name);
   if (auto* field = clang::dyn_cast<clang::FieldDecl>(&decl))
-    return GetNameForDecl(*field, context, name);
+    return GetNameForDecl(*field, context, for_type_trait, name);
   if (auto* function_template =
           clang::dyn_cast<clang::FunctionTemplateDecl>(&decl))
-    return GetNameForDecl(*function_template, context, name);
+    return GetNameForDecl(*function_template, context, for_type_trait, name);
   if (auto* enumc = clang::dyn_cast<clang::EnumConstantDecl>(&decl))
-    return GetNameForDecl(*enumc, context, name);
+    return GetNameForDecl(*enumc, context, for_type_trait, name);
 
   return false;
 }
 
 bool GetNameForDecl(const clang::UsingDecl& decl,
                     clang::ASTContext& context,
+                    bool for_type_trait,
                     std::string& name) {
   assert(decl.shadow_size() > 0);
 
   // If a using declaration's targeted declaration is a set of overloaded
   // functions, it can introduce multiple shadowed declarations. Just using the
   // first one is OK, since overloaded functions have the same name, by
   // definition.
-  return GetNameForDecl(*decl.shadow_begin()->getTargetDecl(), context, name);
+  return GetNameForDecl(*decl.shadow_begin()->getTargetDecl(), context,
+                        for_type_trait, name);
 }
 
 template <typename Type>
 struct TargetNodeTraits;
 
 template <>
 struct TargetNodeTraits<clang::NamedDecl> {
   static clang::SourceLocation GetLoc(const clang::NamedDecl& decl) {
     return decl.getLocation();
   }
@@ skipping 184 matching lines @@
     const DeclNode* decl = result.Nodes.getNodeAs<DeclNode>("decl");
     assert(decl);
     llvm::StringRef old_name = decl->getName();
 
     // Return early if there's no name to be renamed.
     if (!decl->getIdentifier())
       return;
 
     // Get the new name.
     std::string new_name;
-    if (!GetNameForDecl(*decl, *result.Context, new_name))
+    if (!GetNameForDecl(*decl, *result.Context, for_type_traits_, new_name))
       return;  // If false, the name was not suitable for renaming.
 
     // Check if we are able to rewrite the decl (to avoid rewriting if the
     // decl's identifier is part of macro##Token##Concatenation).
     clang::SourceLocation decl_loc =
         TargetNodeTraits<clang::NamedDecl>::GetLoc(*decl);
     if (!Base::GenerateReplacement(result, decl_loc, old_name, new_name,
                                    nullptr))
       return;
 
     Base::AddReplacement(result, old_name, std::move(new_name));
   }
+
+  void set_for_type_traits(bool set) { for_type_traits_ = set; }
+
+ protected:
+  bool for_type_traits_ = false;
 };
 
 using FieldDeclRewriter = DeclRewriterBase<clang::FieldDecl, clang::NamedDecl>;
 using VarDeclRewriter = DeclRewriterBase<clang::VarDecl, clang::NamedDecl>;
 using MemberRewriter = DeclRewriterBase<clang::FieldDecl, clang::MemberExpr>;
 using DeclRefRewriter = DeclRewriterBase<clang::VarDecl, clang::DeclRefExpr>;
 using FieldDeclRefRewriter =
     DeclRewriterBase<clang::FieldDecl, clang::DeclRefExpr>;
 using FunctionDeclRewriter =
     DeclRewriterBase<clang::FunctionDecl, clang::NamedDecl>;
@@ skipping 306 matching lines @@
 
   // Field, variable, and enum declarations ========
   // Given
   //   int x;
   //   struct S {
   //     int y;
   //     enum { VALUE };
   //   };
   // matches |x|, |y|, and |VALUE|.
   auto field_decl_matcher = id("decl", fieldDecl(in_blink_namespace));
-  auto is_type_trait_value =
-      varDecl(hasName("value"), hasStaticStorageDuration(), isPublic(),
-              hasType(isConstQualified()),
-              hasType(type(anyOf(builtinType(), enumType()))),
-              unless(hasAncestor(recordDecl(
-                  has(cxxMethodDecl(isUserProvided(), isInstanceMethod()))))));
+  auto is_type_trait_value = varDecl(
+      anyOf(hasName("value"), isKnownTraitName()), hasStaticStorageDuration(),
+      isPublic(), hasType(isConstQualified()),
+      hasType(type(anyOf(builtinType(), enumType()))),
+      unless(hasAncestor(recordDecl(
+          has(cxxMethodDecl(isUserProvided(), isInstanceMethod()))))));
   auto var_decl_matcher =
       id("decl", varDecl(in_blink_namespace, unless(is_type_trait_value)));
+  auto type_trait_matcher =
+      id("decl", varDecl(is_type_trait_value, unless(hasName("value"))));
   auto enum_member_decl_matcher =
       id("decl", enumConstantDecl(in_blink_namespace));
 
   FieldDeclRewriter field_decl_rewriter(&replacements);
   match_finder.addMatcher(field_decl_matcher, &field_decl_rewriter);
 
   VarDeclRewriter var_decl_rewriter(&replacements);
   match_finder.addMatcher(var_decl_matcher, &var_decl_rewriter);
 
+  VarDeclRewriter type_trait_rewriter(&replacements);
+  type_trait_rewriter.set_for_type_traits(true);
+  match_finder.addMatcher(type_trait_matcher, &type_trait_rewriter);
+
   EnumConstantDeclRewriter enum_member_decl_rewriter(&replacements);
   match_finder.addMatcher(enum_member_decl_matcher, &enum_member_decl_rewriter);
 
   // Field, variable, and enum references ========
   // Given
   //   bool x = true;
   //   if (x) {
   //     ...
   //   }
   // matches |x| in if (x).
@@ skipping 325 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;
 }