Handling of DependentScopeDeclRefExpr and CXXDependentScopeMemberExpr nodes.

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 37 matching lines @@
 namespace {
 
 const char kBlinkFieldPrefix[] = "m_";
 const char kBlinkStaticMemberPrefix[] = "s_";
 const char kGeneratedFileRegex[] = "^gen/|/gen/";
 
 const clang::ast_matchers::internal::
     VariadicDynCastAllOfMatcher<clang::Expr, clang::UnresolvedMemberExpr>
         unresolvedMemberExpr;
 
+const clang::ast_matchers::internal::
+    VariadicDynCastAllOfMatcher<clang::Expr, clang::DependentScopeDeclRefExpr>
+        dependentScopeDeclRefExpr;
+
+const clang::ast_matchers::internal::
+    VariadicDynCastAllOfMatcher<clang::Expr, clang::CXXDependentScopeMemberExpr>
+        cxxDependentScopeMemberExpr;
+
 AST_MATCHER(clang::FunctionDecl, isOverloadedOperator) {
   return Node.isOverloadedOperator();
 }
 
 AST_MATCHER_P(clang::FunctionTemplateDecl,
               templatedDecl,
               clang::ast_matchers::internal::Matcher<clang::FunctionDecl>,
               InnerMatcher) {
   return InnerMatcher.matches(*Node.getTemplatedDecl(), Finder, Builder);
 }
@@ skipping 354 matching lines @@
                     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);
 }
 
+std::string RenameDependentScopeName(const std::string& old_name) {
+  // TODO(lukasza): We don't know if |expr| (i.e. |T::x|) refers to a static
+  // method VS static field VS something else (because we can't tell what |T|
+  // is).  Let's use some simple heuristics for now :-/.
+  std::string new_name;
+  if (old_name.substr(0, 2) == "m_") {
+    new_name = CamelCaseToUnderscoreCase(old_name.substr(2)) + "_";
+  } else {
+    new_name = old_name;
+    new_name[0] = clang::toUppercase(new_name[0]);
+  }

[Łukasz Anforowicz, 2016/08/17 22:45:09]

Not sure if I can/should handle other kinds of renames (e.g. UPPER_CASE ... ->
kUpperCase?).

+  return new_name;
+}
+
+bool GetNameForDecl(const clang::DependentScopeDeclRefExpr& expr,
+                    const clang::ASTContext& context,
+                    std::string& name) {
+  name = RenameDependentScopeName(expr.getDeclName().getAsString());
+  return true;
+}
+
+bool GetNameForDecl(const clang::CXXDependentScopeMemberExpr& expr,
+                    const clang::ASTContext& context,
+                    std::string& name) {
+  name = RenameDependentScopeName(expr.getMember().getAsString());
+  return true;
+}
+
 template <typename Type>
 struct TargetNodeTraits;
 
 template <>
 struct TargetNodeTraits<clang::NamedDecl> {
   static clang::SourceLocation GetLoc(const clang::NamedDecl& decl) {
     return decl.getLocation();
   }
   static const char* GetName() { return "decl"; }
-  static const char* GetType() { return "NamedDecl"; }

[Łukasz Anforowicz, 2016/08/17 22:45:09]

Deleting - this trait was unused AFAICT.

 };
 
 template <>
 struct TargetNodeTraits<clang::MemberExpr> {
   static clang::SourceLocation GetLoc(const clang::MemberExpr& expr) {
     return expr.getMemberLoc();
   }
   static const char* GetName() { return "expr"; }
-  static const char* GetType() { return "MemberExpr"; }
 };
 
 template <>
 struct TargetNodeTraits<clang::DeclRefExpr> {
   static clang::SourceLocation GetLoc(const clang::DeclRefExpr& expr) {
     return expr.getLocation();
   }
   static const char* GetName() { return "expr"; }
-  static const char* GetType() { return "DeclRefExpr"; }
 };
 
 template <>
+struct TargetNodeTraits<clang::DependentScopeDeclRefExpr> {
+  static clang::SourceLocation GetLoc(
+      const clang::DependentScopeDeclRefExpr& expr) {
+    return expr.getLocation();
+  }
+  static const char* GetName() { return "decl"; }
+};
+
+template <>
+struct TargetNodeTraits<clang::CXXDependentScopeMemberExpr> {
+  static clang::SourceLocation GetLoc(
+      const clang::CXXDependentScopeMemberExpr& expr) {
+    return expr.getMemberLoc();
+  }
+  static const char* GetName() { return "decl"; }
+};
+
+template <>
 struct TargetNodeTraits<clang::CXXCtorInitializer> {
   static clang::SourceLocation GetLoc(const clang::CXXCtorInitializer& init) {
     assert(init.isWritten());
     return init.getSourceLocation();
   }
   static const char* GetName() { return "initializer"; }
-  static const char* GetType() { return "CXXCtorInitializer"; }
 };
 
 template <>
 struct TargetNodeTraits<clang::UnresolvedLookupExpr> {
   static clang::SourceLocation GetLoc(const clang::UnresolvedLookupExpr& expr) {
     return expr.getNameLoc();
   }
   static const char* GetName() { return "expr"; }
-  static const char* GetType() { return "UnresolvedLookupExpr"; }
 };
 
 template <>
 struct TargetNodeTraits<clang::UnresolvedMemberExpr> {
   static clang::SourceLocation GetLoc(const clang::UnresolvedMemberExpr& expr) {
     return expr.getMemberLoc();
   }
   static const char* GetName() { return "expr"; }
-  static const char* GetType() { return "UnresolvedMemberExpr"; }
 };
 
+template <typename T>
+bool ContainsIdentifier(const T& node) {
+  return node.getIdentifier() != nullptr;
+}
+
+bool ContainsIdentifier(const clang::DependentScopeDeclRefExpr& expr) {
+  return true;
+}
+
+bool ContainsIdentifier(const clang::CXXDependentScopeMemberExpr& expr) {
+  return true;
+}

[Łukasz Anforowicz, 2016/08/17 22:45:09]

ContainsIdentifier, IsDeclarationMacroTokenConcatenated, GetCurrentName
functions were introduced to allow reuse of RewriterBase for
DependentScopeDeclRefExpr and CXXDependentScopeMemberExpr (otherwise
RewriterBase::run body would refer to members not present in
DependentScopeDeclRefExpr and CXXDependentScopeMemberExpr: getIdentifier,
getName, etc.).

+
+bool IsDeclarationMacroTokenConcatenated(
+    const clang::NamedDecl& decl,
+    const clang::SourceManager& source_manager) {
+  clang::SourceLocation decl_loc = decl.getLocation();
+  if (decl_loc.isMacroID()) {
+    // Get the location of the spelling of the declaration. If token pasting
+    // was used this will be in "scratch space" and we don't know how to get
+    // from there back to/ the actual macro with the foo##bar text. So just
+    // don't replace in that case.
+    clang::SourceLocation spell = source_manager.getSpellingLoc(decl_loc);
+    if (strcmp(source_manager.getBufferName(spell), "<scratch space>") == 0)
+      return true;
+  }
+  return false;
+}
+
+bool IsDeclarationMacroTokenConcatenated(
+    const clang::DependentScopeDeclRefExpr& expr,
+    const clang::SourceManager& source_manager) {
+  return false;  // Heuristic - can't realy tell what |expr| will resolve to...
+}
+
+bool IsDeclarationMacroTokenConcatenated(
+    const clang::CXXDependentScopeMemberExpr& expr,
+    const clang::SourceManager& source_manager) {
+  return false;  // Heuristic - can't realy tell what |expr| will resolve to...
+}
+
+template <typename T>
+std::string GetCurrentName(const T& node) {
+  return node.getName();
+}
+
+std::string GetCurrentName(const clang::DependentScopeDeclRefExpr& expr) {
+  return expr.getDeclName().getAsString();
+}
+
+std::string GetCurrentName(const clang::CXXDependentScopeMemberExpr& expr) {
+  return expr.getMember().getAsString();
+}
+
 template <typename DeclNode, typename TargetNode>
 class RewriterBase : public MatchFinder::MatchCallback {
  public:
   explicit RewriterBase(std::set<Replacement>* replacements)
       : replacements_(replacements) {}
 
   void run(const MatchFinder::MatchResult& result) override {
-    const DeclNode* decl = result.Nodes.getNodeAs<DeclNode>("decl");
-    // If false, there's no name to be renamed.
-    if (!decl->getIdentifier())
+    const DeclNode& decl = *result.Nodes.getNodeAs<DeclNode>("decl");
+
+    if (!ContainsIdentifier(decl))
+      return;  // If false, there's no name to be renamed.
+    if (IsDeclarationMacroTokenConcatenated(decl, *result.SourceManager))
       return;
-    clang::SourceLocation decl_loc =
-        TargetNodeTraits<clang::NamedDecl>::GetLoc(*decl);
-    if (decl_loc.isMacroID()) {
-      // Get the location of the spelling of the declaration. If token pasting
-      // was used this will be in "scratch space" and we don't know how to get
-      // from there back to/ the actual macro with the foo##bar text. So just
-      // don't replace in that case.
-      clang::SourceLocation spell =
-          result.SourceManager->getSpellingLoc(decl_loc);
-      if (strcmp(result.SourceManager->getBufferName(spell),
-                 "<scratch space>") == 0)
-        return;
-    }
-    clang::ASTContext* context = result.Context;
     std::string new_name;
-    if (!GetNameForDecl(*decl, *context, new_name))
+    if (!GetNameForDecl(decl, *result.Context, new_name))
       return;  // If false, the name was not suitable for renaming.
-    llvm::StringRef old_name = decl->getName();
+    llvm::StringRef old_name = GetCurrentName(decl);
     if (old_name == new_name)
       return;
+
     clang::SourceLocation loc = TargetNodeTraits<TargetNode>::GetLoc(
         *result.Nodes.getNodeAs<TargetNode>(
             TargetNodeTraits<TargetNode>::GetName()));
     clang::CharSourceRange range = clang::CharSourceRange::getTokenRange(loc);
     replacements_->emplace(*result.SourceManager, range, new_name);
     replacement_names_.emplace(old_name.str(), std::move(new_name));
   }
 
   const std::unordered_map<std::string, std::string>& replacement_names()
       const {
@@ skipping 28 matching lines @@
 using EnumConstantDeclRefRewriter =
     RewriterBase<clang::EnumConstantDecl, clang::DeclRefExpr>;
 
 using UnresolvedLookupRewriter =
     RewriterBase<clang::NamedDecl, clang::UnresolvedLookupExpr>;
 using UnresolvedMemberRewriter =
     RewriterBase<clang::NamedDecl, clang::UnresolvedMemberExpr>;
 
 using UsingDeclRewriter = RewriterBase<clang::UsingDecl, clang::NamedDecl>;
 
+using DependentScopeDeclRefExprRewriter =
+    RewriterBase<clang::DependentScopeDeclRefExpr,
+                 clang::DependentScopeDeclRefExpr>;
+
+using CXXDependentScopeMemberExprRewriter =
+    RewriterBase<clang::CXXDependentScopeMemberExpr,
+                 clang::CXXDependentScopeMemberExpr>;
+
 }  // namespace
 
 static llvm::cl::extrahelp common_help(CommonOptionsParser::HelpMessage);
 
 int main(int argc, const char* argv[]) {
   // TODO(dcheng): Clang tooling should do this itself.
   // http://llvm.org/bugs/show_bug.cgi?id=21627
   llvm::InitializeNativeTarget();
   llvm::InitializeNativeTargetAsmParser();
   llvm::cl::OptionCategory category(
       "rewrite_to_chrome_style: convert Blink style to Chrome style.");
   CommonOptionsParser options(argc, argv, category);
   clang::tooling::ClangTool tool(options.getCompilations(),
                                  options.getSourcePathList());
 
   MatchFinder match_finder;
   std::set<Replacement> replacements;
 
   auto in_blink_namespace =
-      decl(hasAncestor(namespaceDecl(anyOf(hasName("blink"), hasName("WTF")),
-                                     hasParent(translationUnitDecl()))),
-           unless(isExpansionInFileMatching(kGeneratedFileRegex)));
+      allOf(hasAncestor(namespaceDecl(anyOf(hasName("blink"), hasName("WTF")),

[Łukasz Anforowicz, 2016/08/17 22:45:09]

s/decl/allOf/ because DependentScopeDeclRefExpr and CXXDependentScopeMemberExpr
are not a "decl" (i.e. their matchers do not accept a matcher/filter limited to
decls only [like |in_blink_namespace| was before this change]).

+                                      hasParent(translationUnitDecl()))),
+            unless(isExpansionInFileMatching(kGeneratedFileRegex)));
 
   // Field, variable, and enum declarations ========
   // Given
   //   int x;
   //   struct S {
   //     int y;
   //     enum { VALUE };
   //   };
   // matches |x|, |y|, and |VALUE|.
   auto field_decl_matcher = id("decl", fieldDecl(in_blink_namespace));
@@ skipping 227 matching lines @@
   //   using blink::X;
   // matches |using blink::X|.
   auto using_decl_matcher = id(
       "decl", usingDecl(hasAnyUsingShadowDecl(hasTargetDecl(anyOf(
                   var_decl_matcher, field_decl_matcher, function_decl_matcher,
                   method_decl_matcher, function_template_decl_matcher,
                   method_template_decl_matcher, enum_member_decl_matcher)))));
   UsingDeclRewriter using_decl_rewriter(&replacements);
   match_finder.addMatcher(using_decl_matcher, &using_decl_rewriter);
 
+  // Template-dependent decl lookup ========
+  // Given
+  //   template <typename T> void f() { T::foo(); }
+  // matches |T::foo|.
+  auto dependent_scope_decl_ref_expr_matcher =
+      expr(id("decl", dependentScopeDeclRefExpr(in_blink_namespace)));

[Łukasz Anforowicz, 2016/08/17 22:45:09]

One could argue that I should say "expr" instead of "decl" above... But
RewriterBase::run hardcodes "decl"...  Path of least resistance... :-)  One
alternative would be to have a trait for GetTargetName (old GetName) and for
GetSourceName) - this seems like too much trouble IMO.

+  DependentScopeDeclRefExprRewriter dependent_scope_decl_ref_expr_rewriter(
+      &replacements);
+  match_finder.addMatcher(dependent_scope_decl_ref_expr_matcher,
+                          &dependent_scope_decl_ref_expr_rewriter);
+
+  // Template-dependent member lookup ========
+  // Given
+  //   template <typename T>
+  //   class Foo {
+  //     void f() { T::foo(); }
+  //   };
+  // matches |T::foo|.
+  auto cxx_dependent_scope_member_expr_matcher =
+      expr(id("decl", cxxDependentScopeMemberExpr(in_blink_namespace)));
+  CXXDependentScopeMemberExprRewriter cxx_dependent_scope_member_expr_rewriter(
+      &replacements);
+  match_finder.addMatcher(cxx_dependent_scope_member_expr_matcher,
+                          &cxx_dependent_scope_member_expr_rewriter);
+
   std::unique_ptr<clang::tooling::FrontendActionFactory> factory =
       clang::tooling::newFrontendActionFactory(&match_finder);
   int result = tool.run(factory.get());
   if (result != 0)
     return result;
 
 #if defined(_WIN32)
   HANDLE lockfd = CreateFile("rewrite-sym.lock", GENERIC_READ, FILE_SHARE_READ,
                              NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
   OVERLAPPED overlapped = {};
@@ skipping 31 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;
 }