Add a hardcoded list of methods that need a "Get" prefix.

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 322 matching lines @@
 
   // If the expression can be evaluated at compile time, then it should have a
   // kFoo style name. Otherwise, not.
   return initializer->isEvaluatable(context);
 }
 
 AST_MATCHER_P(clang::QualType, hasString, std::string, ExpectedString) {
   return ExpectedString == Node.getAsString();
 }
 
+bool IsMethodNameLikelyToConflictWithTypeName(std::string method_name) {

[dcheng, 2016/12/19 19:26:52]

Just call this ShouldPrefixMethodName ('likely' is a bit handwavy, since that
*something* definitely conflicts if it's in this list)

[Łukasz Anforowicz, 2016/12/19 21:58:47]

Done.

+  // Make sure that IsMethodNameLikelyToConflictWithTypeName works
+  // both when |method_name| is the old and/or the new name.
+  method_name[0] = clang::toLowercase(method_name[0]);

[dcheng, 2016/12/19 19:26:52]

As discussed, I think we shouldn't need this:
- if the input is NamedLikeThis, if it will conflict with something, it already
does. So we just check for namesLikeThis.

[Łukasz Anforowicz, 2016/12/19 21:58:47]

Done.  (OTOH, please note that this is why I also had to move where the call
occurs within GetNameForDecl below)

+
+  // Methods that are named similarily to a type - they should be prefixed
+  // with a "get" prefix.
+  static const char* kConflictingMethods[] = {
+    "entryType",
+    "readyState",

[Łukasz Anforowicz, 2016/12/19 19:07:35]

Nasko, can you help populate this list with more instances of the TypeName type
vs typeName() method/accessor problem?

[Łukasz Anforowicz, 2016/12/20 00:32:05]

I've populated this list with the errors I've seen so far - maybe this is good
enough for now (at least good enough to land this CL + retry what else is
missing after rerunning the rename tool).

+  };
+  for (const auto& conflicting_method : kConflictingMethods) {
+    if (method_name == conflicting_method)
+      return true;
+  }
+
+  return false;
+}
+
 bool GetNameForDecl(const clang::FunctionDecl& decl,
                     clang::ASTContext& context,
                     std::string& name) {
   name = decl.getName().str();
   name[0] = clang::toUppercase(name[0]);
 
   // Given
   //   class Foo {};
   //   class DerivedFoo : class Foo;
   //   using Bar = Foo;
@@ skipping 13 matching lines @@
   // - Foo foo()  // Direct application of |type_with_same_name_as_function|.
   // - Foo* foo()  // |hasDescendant| traverses references/pointers.
   // - RefPtr<Foo> foo()  // |hasDescendant| traverses template arguments.
   auto type_containing_same_name_as_function =
       qualType(anyOf(type_with_same_name_as_function,
                      hasDescendant(type_with_same_name_as_function)));
   // https://crbug.com/582312: Prepend "Get" if method name conflicts with
   // return type.
   auto conflict_matcher =
       functionDecl(returns(type_containing_same_name_as_function));
-  if (IsMatching(conflict_matcher, decl, context))
+  bool return_type_conflicts_with_method_name =
+      IsMatching(conflict_matcher, decl, context);
+
+  if (return_type_conflicts_with_method_name ||
+      IsMethodNameLikelyToConflictWithTypeName(name)) {
     name = "Get" + name;
+  }
 
   return true;
 }
 
 bool GetNameForDecl(const clang::EnumConstantDecl& decl,
                     clang::ASTContext& context,
                     std::string& name) {
   StringRef original_name = decl.getName();
 
   // If it's already correct leave it alone.
@@ skipping 434 matching lines @@
         new_name = CamelCaseToUnderscoreCase(field_name) + "_";
         return true;
       }
     }
 
     // |T::myMethod(...)| -> |T::MyMethod(...)|.
     if ((old_name.find('_') == std::string::npos) && IsCallee(node, context) &&
         !IsBlacklistedFunctionOrMethodName(old_name)) {
       new_name = old_name;
       new_name[0] = clang::toUppercase(old_name[0]);
+      if (IsMethodNameLikelyToConflictWithTypeName(new_name))
+        new_name = "Get" + new_name;
       return true;
     }
 
     // In the future we can consider more heuristics:
     // - "s_" and "g_" prefixes
     // - "ALL_CAPS"
     // - |T::myStaticField| -> |T::kMyStaticField|
     //   (but have to be careful not to rename |value| in WTF/TypeTraits.h?)
     return false;
   }
@@ skipping 423 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;
 }