Prepend "Get" to method name if method name conflicts with return type name.

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 319 matching lines @@
   // isEvaluable().
   if (initializer->isInstantiationDependent())
     return false;
 
   // 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::FunctionDecl& decl,
-                    const clang::ASTContext& context,
+                    clang::ASTContext& context,

[Łukasz Anforowicz, 2016/08/24 18:09:49]

|match| function call below takes a non-const ASTContext& as an argument.

                     std::string& name) {
   name = decl.getName().str();
   name[0] = clang::toUppercase(name[0]);
+
+  // https://crbug.com/582312: Prepend "Get" if method name conflicts with type.
+  auto base_matcher =
+      hasCanonicalType(hasDeclaration(namedDecl(hasName(name))));

[dcheng, 2016/08/25 17:36:00]

Can we just pull the return type out of the FunctionDecl rather than running a
matcher?

I think we can just do:
  decl.getReturnType()->getBaseTypeIdentifier()->getName()

Which has the advantage that it'll work with multiple layers of indirection.

[Łukasz Anforowicz, 2016/08/25 18:30:40]

Thanks - done.  I didn't know about getBaseTypeIdentifier - I was using the
matcher mainly to strip pointers+references, but your suggestion is obviously
better.

RE: multiple layers of indirection - this might also be a problem in
https://codereview.chromium.org/2256913002 - I've left a comment there.

+  auto conflict_matcher = qualType(
+      anyOf(pointsTo(base_matcher), references(base_matcher), base_matcher));
+  if (!match(conflict_matcher, decl.getReturnType(), context).empty())
+    name = "Get" + name;
+
   return true;
 }
 
 bool GetNameForDecl(const clang::EnumConstantDecl& decl,
-                    const clang::ASTContext& context,
+                    clang::ASTContext& context,

[Łukasz Anforowicz, 2016/08/24 18:09:49]

Best to be consistent here (i.e. use non-const in all overloads) - otherwise
overload resolution + templates is very confusing (at one point I had non-const
only in 2 places - it resulted in a warning that one of the GetNameForDecl
overloads is unused... :-/ ).

                     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,
-                    const clang::ASTContext& context,
+                    clang::ASTContext& context,
                     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
@@ skipping 10 matching lines @@
       clang::isUppercase(original_name[1]))
     return false;
 
   name = 'k';
   name.append(original_name.data(), original_name.size());
   name[1] = clang::toUppercase(name[1]);
   return true;
 }
 
 bool GetNameForDecl(const clang::VarDecl& decl,
-                    const clang::ASTContext& context,
+                    clang::ASTContext& context,
                     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| really covers text of |original_name|.  This might not be
     // true when specializing a templatized class that had an unnamed parameter
@@ skipping 42 matching lines @@
   // Static members end with _ just like other members, but constants should
   // not.
   if (!is_const && decl.isStaticDataMember()) {
     name += '_';
   }
 
   return true;
 }
 
 bool GetNameForDecl(const clang::FunctionTemplateDecl& decl,
-                    const clang::ASTContext& context,
+                    clang::ASTContext& context,
                     std::string& name) {
   clang::FunctionDecl* templated_function = decl.getTemplatedDecl();
   return GetNameForDecl(*templated_function, context, name);
 }
 
 bool GetNameForDecl(const clang::NamedDecl& decl,
-                    const clang::ASTContext& context,
+                    clang::ASTContext& context,
                     std::string& name) {
   if (auto* function = clang::dyn_cast<clang::FunctionDecl>(&decl))
     return GetNameForDecl(*function, context, name);
   if (auto* var = clang::dyn_cast<clang::VarDecl>(&decl))
     return GetNameForDecl(*var, context, name);
   if (auto* field = clang::dyn_cast<clang::FieldDecl>(&decl))
     return GetNameForDecl(*field, context, name);
   if (auto* function_template =
           clang::dyn_cast<clang::FunctionTemplateDecl>(&decl))
     return GetNameForDecl(*function_template, context, name);
   if (auto* enumc = clang::dyn_cast<clang::EnumConstantDecl>(&decl))
     return GetNameForDecl(*enumc, context, name);
 
   return false;
 }
 
 bool GetNameForDecl(const clang::UsingDecl& decl,
-                    const clang::ASTContext& context,
+                    clang::ASTContext& context,
                     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);
 }
 
@@ skipping 667 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;
 }