rewrite_to_chrome_style: Check expression is const when deciding style

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 31 matching lines @@
 
 namespace {
 
 AST_MATCHER(clang::FunctionDecl, isOverloadedOperator) {
   return Node.isOverloadedOperator();
 }
 
 constexpr char kBlinkFieldPrefix[] = "m_";
 constexpr char kBlinkStaticMemberPrefix[] = "s_";
 
-bool GetNameForDecl(const clang::FunctionDecl& decl, std::string& name) {
+bool GetNameForDecl(const clang::FunctionDecl& decl,
+                    const clang::ASTContext& context,
+                    std::string& name) {
   name = decl.getNameAsString();
   name[0] = clang::toUppercase(name[0]);
   return true;
 }
 
 // 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;
@@ skipping 19 matching lines @@
     // needs a '_' in 'dL'.
     if (i != input.bytes_end() - 1 && was_lowercase && is_uppercase)
       needs_underscore = true;
     was_lowercase = is_lowercase;
     was_uppercase = is_uppercase;
   }
   std::reverse(output.begin(), output.end());
   return output;
 }
 
-bool GetNameForDecl(const clang::FieldDecl& decl, std::string& name) {
+bool GetNameForDecl(const clang::FieldDecl& decl,
+                    const clang::ASTContext& context,
+                    std::string& name) {
   StringRef original_name = decl.getName();
   // Blink style field names are prefixed with `m_`. If this prefix isn't
   // present, assume it's already been converted to Google style.
   if (original_name.size() < strlen(kBlinkFieldPrefix) ||
       !original_name.startswith(kBlinkFieldPrefix))
     return false;
   name = CamelCaseToUnderscoreCase(
       original_name.substr(strlen(kBlinkFieldPrefix)));
   // The few examples I could find used struct-style naming with no `_` suffix
   // for unions.
   if (decl.getParent()->isClass())
     name += '_';
   return true;
 }
 
-bool IsProbablyConst(const clang::VarDecl& decl) {
+bool IsProbablyConst(const clang::VarDecl& decl,
+                     const clang::ASTContext& context) {
   clang::QualType type = decl.getType();
   if (!type.isConstQualified())
     return false;
 
   if (type.isVolatileQualified())
     return false;
 
   // http://google.github.io/styleguide/cppguide.html#Constant_Names
   // Static variables that are const-qualified should use kConstantStyle naming.
   if (decl.getStorageDuration() == clang::SD_Static)
     return true;
 
-  // Otherwise, use a simple heuristic: if it's initialized with a literal of
-  // some sort, also use kConstantStyle naming.
   const clang::Expr* initializer = decl.getInit();
   if (!initializer)
     return false;
 
-  // Ignore implicit casts, so the literal check below still matches on
-  // array-to-pointer decay, e.g.
-  //   const char* const kConst = "...";
-  if (const clang::ImplicitCastExpr* cast_expr =
-          clang::dyn_cast<clang::ImplicitCastExpr>(initializer))
-    initializer = cast_expr->getSubExprAsWritten();
-
-  return clang::isa<clang::CharacterLiteral>(initializer) ||
-         clang::isa<clang::CompoundLiteralExpr>(initializer) ||
-         clang::isa<clang::CXXBoolLiteralExpr>(initializer) ||
-         clang::isa<clang::CXXNullPtrLiteralExpr>(initializer) ||
-         clang::isa<clang::FloatingLiteral>(initializer) ||
-         clang::isa<clang::IntegerLiteral>(initializer) ||
-         clang::isa<clang::StringLiteral>(initializer) ||
-         clang::isa<clang::UserDefinedLiteral>(initializer);
+  // If the expression can be evaluated at compile time, then it should have a
+  // kFoo style name. Otherwise, not.
+  return initializer->isEvaluatable(context);
 }
 
-bool GetNameForDecl(const clang::VarDecl& decl, std::string& name) {
+bool GetNameForDecl(const clang::VarDecl& decl,
+                    const clang::ASTContext& context,
+                    std::string& name) {
   StringRef original_name = decl.getName();
 
   // Nothing to do for unnamed parameters.
   if (clang::isa<clang::ParmVarDecl>(decl) && original_name.empty())
     return false;
 
   // 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));
 
-  if (IsProbablyConst(decl)) {
+  if (IsProbablyConst(decl, context)) {
     // 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;
     name = 'k';
     name.append(original_name.data(), original_name.size());
     name[1] = clang::toUppercase(name[1]);
   } else {
     name = CamelCaseToUnderscoreCase(original_name);
   }
@@ skipping 47 matching lines @@
 
 template <typename DeclNode, typename TargetNode>
 class RewriterBase : public MatchFinder::MatchCallback {
  public:
   explicit RewriterBase(Replacements* replacements)
       : replacements_(replacements) {}
 
   void run(const MatchFinder::MatchResult& result) override {
     std::string name;
     const DeclNode* decl = result.Nodes.getNodeAs<DeclNode>("decl");
-    if (!GetNameForDecl(*decl, name))
+    clang::ASTContext* context = result.Context;
+    if (!GetNameForDecl(*decl, *context, name))
       return;
     auto r = replacements_->emplace(
         *result.SourceManager, TargetNodeTraits<TargetNode>::GetRange(
                                    *result.Nodes.getNodeAs<TargetNode>(
                                        TargetNodeTraits<TargetNode>::kName)),
         name);
     auto from = decl->getNameAsString();
     auto to = r.first->getReplacementText().str();
     if (from != to)
       replacement_names_.emplace(std::move(from), std::move(to));
@@ skipping 291 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;
 }