Avoid calling getName() on declarations that don't have an associated identifier.

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 117 matching lines @@
 }
 
 class MethodBlocklist {
  public:
   explicit MethodBlocklist(const std::string& filepath) {
     if (!filepath.empty())
       ParseInputFile(filepath);
   }
 
   bool Contains(const clang::FunctionDecl& method) const {
+    if (!method.getDeclName().isIdentifier())
+      return false;
+
     auto it = method_to_class_to_args_.find(method.getName());
     if (it == method_to_class_to_args_.end())
       return false;
 
     // |method_context| is either
     // 1) a CXXRecordDecl (i.e. blink::Document) or
     // 2) a NamespaceDecl (i.e. blink::DOMWindowTimers).
     const clang::NamedDecl* method_context =
         clang::dyn_cast<clang::NamedDecl>(method.getDeclContext());
     if (!method_context)
       return false;
+    if (!method_context->getDeclName().isIdentifier())
+      return false;
 
     const llvm::StringMap<std::set<unsigned>>& class_to_args = it->second;
     auto it2 = class_to_args.find(method_context->getName());
     if (it2 == class_to_args.end())
       return false;
 
     const std::set<unsigned>& arg_counts = it2->second;
     unsigned method_param_count = method.param_size();
     unsigned method_non_optional_param_count = method_param_count;
     for (const clang::ParmVarDecl* param : method.parameters()) {
@@ skipping 288 matching lines @@
   }
   return false;
 }
 
 bool IsBlacklistedMethodName(llvm::StringRef name) {
   return IsBlacklistedFunctionName(name) ||
          IsBlacklistedInstanceMethodName(name);
 }
 
 bool IsBlacklistedFunction(const clang::FunctionDecl& decl) {
+  if (!decl.getDeclName().isIdentifier())
+    return false;
+
   clang::StringRef name = decl.getName();
   return IsBlacklistedFunctionName(name) || IsBlacklistedFreeFunctionName(name);
 }
 
 bool IsBlacklistedMethod(const clang::CXXMethodDecl& decl) {
+  if (!decl.getDeclName().isIdentifier())
+    return false;
+
   clang::StringRef name = decl.getName();
   if (IsBlacklistedFunctionName(name))
     return true;
 
   // Remaining cases are only applicable to instance methods.
   if (decl.isStatic())
     return false;
 
   if (IsBlacklistedInstanceMethodName(name))
     return true;
@@ skipping 15 matching lines @@
 AST_MATCHER(clang::CXXMethodDecl, isBlacklistedMethod) {
   return IsBlacklistedMethod(Node);
 }
 
 bool IsKnownTraitName(clang::StringRef name) {
   // This set of names is globally a type trait throughout chromium.
   return name == "safeToCompareToEmptyOrDeleted";
 }
 
 AST_MATCHER(clang::VarDecl, isKnownTraitName) {
-  return IsKnownTraitName(Node.getName());
+  return Node.getDeclName().isIdentifier() && IsKnownTraitName(Node.getName());
 }
 
 // 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;
   bool was_lowercase = false;
   bool was_uppercase = false;
   bool first_char = true;
@@ skipping 210 matching lines @@
   };
   for (const auto& conflicting_method : kConflictingMethods) {
     if (old_method_name == conflicting_method)
       return true;
   }
 
   return false;
 }
 
 AST_MATCHER(clang::FunctionDecl, shouldPrefixFunctionName) {
-  return ShouldPrefixFunctionName(Node.getName().str());
+  return Node.getDeclName().isIdentifier() &&
+      ShouldPrefixFunctionName(Node.getName().str());
 }
 
 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 {};
@@ skipping 385 matching lines @@
 template <typename DeclNode, typename TargetNode>
 class DeclRewriterBase : public RewriterBase<TargetNode> {
  public:
   using Base = RewriterBase<TargetNode>;
 
   explicit DeclRewriterBase(std::set<Replacement>* replacements)
       : Base(replacements) {}
 
   void run(const MatchFinder::MatchResult& result) override {
     const DeclNode* decl = result.Nodes.getNodeAs<DeclNode>("decl");
+    if (!decl->getDeclName().isIdentifier())
+      return;
+
     assert(decl);
     llvm::StringRef old_name = decl->getName();

[Łukasz Anforowicz, 2017/02/02 22:51:42]

In theory a few GetNameForDecl should also be protected, but they are only
called from DeclRewriterBase::run, so we should be fine as-is.

 
     // 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, new_name))
       return;  // If false, the name was not suitable for renaming.
 
@@ skipping 697 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;
 }