rewrite_to_chrome_style: Rewrite references to members through the class

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 365 matching lines @@
 
 template <typename Type>
 struct TargetNodeTraits;
 
 template <>
 struct TargetNodeTraits<clang::NamedDecl> {
   static const char kName[];
   static clang::SourceLocation GetLoc(const clang::NamedDecl& decl) {
     return decl.getLocation();
   }
+  static const char* GetType() { return "NamedDecl"; }
 };
 const char TargetNodeTraits<clang::NamedDecl>::kName[] = "decl";
 
 template <>
 struct TargetNodeTraits<clang::MemberExpr> {
   static const char kName[];
   static clang::SourceLocation GetLoc(const clang::MemberExpr& expr) {
     return expr.getMemberLoc();
   }
+  static const char* GetType() { return "MemberExpr"; }
 };
 const char TargetNodeTraits<clang::MemberExpr>::kName[] = "expr";
 
 template <>
 struct TargetNodeTraits<clang::DeclRefExpr> {
   static const char kName[];
   static clang::SourceLocation GetLoc(const clang::DeclRefExpr& expr) {
     return expr.getLocation();
   }
+  static const char* GetType() { return "DeclRefExpr"; }
 };
 const char TargetNodeTraits<clang::DeclRefExpr>::kName[] = "expr";
 
 template <>
 struct TargetNodeTraits<clang::CXXCtorInitializer> {
   static const char kName[];
   static clang::SourceLocation GetLoc(const clang::CXXCtorInitializer& init) {
     assert(init.isWritten());
     return init.getSourceLocation();
   }
+  static const char* GetType() { return "CXXCtorInitializer"; }
 };
 const char TargetNodeTraits<clang::CXXCtorInitializer>::kName[] = "initializer";
 
 template <typename DeclNode, typename TargetNode>
 class RewriterBase : public MatchFinder::MatchCallback {
  public:
   explicit RewriterBase(Replacements* replacements)
       : replacements_(replacements) {}
 
   void run(const MatchFinder::MatchResult& result) override {
@@ skipping 29 matching lines @@
 
  private:
   Replacements* const replacements_;
   std::unordered_map<std::string, std::string> replacement_names_;
 };
 
 using FieldDeclRewriter = RewriterBase<clang::FieldDecl, clang::NamedDecl>;
 using VarDeclRewriter = RewriterBase<clang::VarDecl, clang::NamedDecl>;
 using MemberRewriter = RewriterBase<clang::FieldDecl, clang::MemberExpr>;
 using DeclRefRewriter = RewriterBase<clang::VarDecl, clang::DeclRefExpr>;
+using FieldDeclRefRewriter = RewriterBase<clang::FieldDecl, clang::DeclRefExpr>;
 using FunctionDeclRewriter =
     RewriterBase<clang::FunctionDecl, clang::NamedDecl>;
 using FunctionRefRewriter =
     RewriterBase<clang::FunctionDecl, clang::DeclRefExpr>;
 using ConstructorInitializerRewriter =
     RewriterBase<clang::FieldDecl, clang::CXXCtorInitializer>;
 
 using MethodDeclRewriter = RewriterBase<clang::CXXMethodDecl, clang::NamedDecl>;
 using MethodRefRewriter =
     RewriterBase<clang::CXXMethodDecl, clang::DeclRefExpr>;
@@ skipping 79 matching lines @@
 
   MemberRewriter member_rewriter(&replacements);
   match_finder.addMatcher(member_matcher, &member_rewriter);
 
   DeclRefRewriter decl_ref_rewriter(&replacements);
   match_finder.addMatcher(decl_ref_matcher, &decl_ref_rewriter);
 
   EnumConstantDeclRefRewriter enum_member_ref_rewriter(&replacements);
   match_finder.addMatcher(enum_member_ref_matcher, &enum_member_ref_rewriter);
 
+  // Member references in a non-member context ========
+  // Given
+  //   struct S {
+  //     typedef int U::*UnspecifiedBoolType;
+  //     operator UnspecifiedBoolType() { return s_ ? &U::s_ : 0; }
+  //     int s_;
+  //   };
+  // matches |&U::s_| but not |s_|.
+  auto member_ref_matcher = id(
+      "expr",
+      declRefExpr(
+          to(field_decl_matcher),
+          // Needed to avoid matching member references in functions (which will
+          // be an ancestor of the member reference) synthesized by the
+          // compiler, such as a synthesized copy constructor.
+          // This skips explicitly defaulted functions as well, but that's OK:
+          // there's nothing interesting to rewrite in those either.
+          unless(hasAncestor(functionDecl(internal_hack::isDefaulted())))));

[dcheng, 2016/03/04 01:41:55]

I think we might not need this, cause the things you can default probably won't
reference the member like this, right? At least I can't think of a reason where
the compiler would synthesize something like this.

[danakj, 2016/03/04 01:55:51]

I couldn't think of it offhand, but then I thought who knows.. I can remove it
and we see if we get errors. Please try remember this, cuz I'll forget. :)

+
+  FieldDeclRefRewriter member_ref_rewriter(&replacements);
+  match_finder.addMatcher(member_ref_matcher, &member_ref_rewriter);
+
   // Non-method function declarations ========
   // Given
   //   void f();
   //   struct S {
   //     void g();
   //   };
   // matches |f| but not |g|.
   auto function_decl_matcher = id(
       "decl",
       functionDecl(
@@ skipping 140 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;
 }