Skip parameter replacements where old text != old 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 254 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,
                     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.
   const clang::IdentifierInfo* return_type =
       decl.getReturnType().getBaseTypeIdentifier();
   if (return_type && return_type->getName() == name)
     name = "Get" + name;
 
   return true;
 }
 
 bool GetNameForDecl(const clang::EnumConstantDecl& decl,
-                    const clang::ASTContext& context,
+                    clang::ASTContext& context,
                     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
   // suffix _.
   if (member_prefix && name.back() != '_')
     name += '_';
 
   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) && original_name.empty())
-    return false;
+  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;
+  }
 
   // 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));
 
   bool is_const = IsProbablyConst(decl, context);
@@ skipping 20 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 452 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;
 }