Force the safeToCompareToEmptyOrDeleted trait to be renamed correctly

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 712 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
     // 1) have decl.getLocation() pointing at a parameter declaration without a
     // name, but 2) have decl.getName() retained from a template specialization
     // of a method.  See also: https://llvm.org/bugs/show_bug.cgi?id=29145
     clang::SourceLocation loc =
         context.getSourceManager().getSpellingLoc(decl.getLocation());
     auto parents = context.getParents(decl);
     bool is_child_location_within_parent_source_range = std::all_of(
         parents.begin(), parents.end(),
         [&loc](const clang::ast_type_traits::DynTypedNode& parent) {
           clang::SourceLocation begin = parent.getSourceRange().getBegin();
           clang::SourceLocation end = parent.getSourceRange().getEnd();
           return (begin < loc) && (loc < end);
         });
     if (!is_child_location_within_parent_source_range)
       return false;
   }
 
+  // This is a type trait that appears in consumers of WTF as well as inside
+  // WTF. We want it to be named in this_style_of_case accordingly.
+  if (IsKnownTraitName(original_name)) {
+    name = CamelCaseToUnderscoreCase(original_name);
+    return true;
+  }
+
   // 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, for_type_trait, name);
+  return GetNameForDecl(*templated_function, context, 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, for_type_trait, name);
+    return GetNameForDecl(*function, context, name);
   if (auto* var = clang::dyn_cast<clang::VarDecl>(&decl))
-    return GetNameForDecl(*var, context, for_type_trait, name);
+    return GetNameForDecl(*var, context, name);
   if (auto* field = clang::dyn_cast<clang::FieldDecl>(&decl))
-    return GetNameForDecl(*field, context, for_type_trait, name);
+    return GetNameForDecl(*field, context, name);
   if (auto* function_template =
           clang::dyn_cast<clang::FunctionTemplateDecl>(&decl))
-    return GetNameForDecl(*function_template, context, for_type_trait, name);
+    return GetNameForDecl(*function_template, context, name);
   if (auto* enumc = clang::dyn_cast<clang::EnumConstantDecl>(&decl))
-    return GetNameForDecl(*enumc, context, for_type_trait, name);
+    return GetNameForDecl(*enumc, context, 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,
-                        for_type_trait, name);
+  return GetNameForDecl(*decl.shadow_begin()->getTargetDecl(), context, 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, for_type_traits_, new_name))
+    if (!GetNameForDecl(*decl, *result.Context, 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 307 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(
-      anyOf(hasName("value"), isKnownTraitName()), hasStaticStorageDuration(),
-      isPublic(), hasType(isConstQualified()),
-      hasType(type(anyOf(builtinType(), enumType()))),
-      unless(hasAncestor(recordDecl(
-          has(cxxMethodDecl(isUserProvided(), isInstanceMethod()))))));
+  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 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 type_trait_decl_matcher = id("decl", varDecl(isKnownTraitName()));

[dcheng, 2017/01/31 00:01:05]

Is it OK to skip is_type_trait_value here now?

[danakj, 2017/01/31 00:02:32]

Yeh, we'll just do it for all names that match now no matter what, in any
namespace, whatever const-ness, etc.

[danakj, 2017/01/31 00:03:06]

It will match any vardecl in the codebase, but it has to have that name, and
it's unique to this.

[dcheng, 2017/01/31 00:08:31]

I'm probably missing something, but don't we need is_type_trait_value here to
camel case the other type traits too? Or are they already renamed correctly, and
it's just this one that the rewriter struggles with?

[danakj, 2017/01/31 00:09:58]

Right, the other ones are all named value and are covered above as such.

   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);
+  match_finder.addMatcher(type_trait_decl_matcher, &var_decl_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).
   auto member_matcher = id(
       "expr",
       memberExpr(
           member(field_decl_matcher),
           // Needed to avoid matching member references in functions (which will
           // be an ancestor of the member reference) synthesized by the
           // compiler, such as a synthesized copy constructor.
           // This skips explicitly defaulted functions as well, but that's OK:
           // there's nothing interesting to rewrite in those either.
           unless(hasAncestor(functionDecl(isDefaulted())))));
   auto decl_ref_matcher = id("expr", declRefExpr(to(var_decl_matcher)));
-  auto type_trait_ref_matcher = id("expr", declRefExpr(to(type_trait_matcher)));
+  auto type_trait_ref_matcher =
+      id("expr", declRefExpr(to(type_trait_decl_matcher)));
   auto enum_member_ref_matcher =
       id("expr", declRefExpr(to(enum_member_decl_matcher)));
 
   MemberRewriter member_rewriter(&replacements);
   match_finder.addMatcher(member_matcher, &member_rewriter);
 
   DeclRefRewriter decl_ref_rewriter(&replacements);
   match_finder.addMatcher(decl_ref_matcher, &decl_ref_rewriter);
-
-  DeclRefRewriter type_trait_ref_rewriter(&replacements);
-  type_trait_ref_rewriter.set_for_type_traits(true);
-  match_finder.addMatcher(type_trait_ref_matcher, &type_trait_ref_rewriter);
+  match_finder.addMatcher(type_trait_ref_matcher, &decl_ref_rewriter);
 
   EnumConstantDeclRefRewriter enum_member_ref_rewriter(&replacements);
   match_finder.addMatcher(enum_member_ref_matcher, &enum_member_ref_rewriter);
 
   // Member references in a non-member context ========
   // Given
   //   struct S {
   //     typedef int U::*UnspecifiedBoolType;
   //     operator UnspecifiedBoolType() { return s_ ? &U::s_ : 0; }
   //     int s_;
@@ skipping 298 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;
 }