rewrite_to_chrome_style: skip nodes in synthesized functions.

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 35 matching lines @@
 using clang::tooling::Replacement;
 using clang::tooling::Replacements;
 using llvm::StringRef;
 
 namespace {
 
 AST_MATCHER(clang::FunctionDecl, isOverloadedOperator) {
   return Node.isOverloadedOperator();
 }
 
+// This is available in newer clang revisions... but alas, Chrome has not rolled
+// that far yet.
+AST_MATCHER(clang::FunctionDecl, isDefaulted) {
+  return Node.isDefaulted();
+}
+
 const char kBlinkFieldPrefix[] = "m_";
 const char kBlinkStaticMemberPrefix[] = "s_";
 
 bool GetNameForDecl(const clang::FunctionDecl& decl,
                     const clang::ASTContext& context,
                     std::string& name) {
   name = decl.getNameAsString();
 
   if (const auto* method = clang::dyn_cast<const clang::CXXMethodDecl>(&decl)) {
     if (!method->isStatic()) {
@@ skipping 156 matching lines @@
     return clang::CharSourceRange::getTokenRange(expr.getLocation());
   }
 };
 const char TargetNodeTraits<clang::DeclRefExpr>::kName[] = "expr";
 
 template <>
 struct TargetNodeTraits<clang::CXXCtorInitializer> {
   static const char kName[];
   static clang::CharSourceRange GetRange(
       const clang::CXXCtorInitializer& init) {
+    assert(init.isWritten());
     return clang::CharSourceRange::getTokenRange(init.getSourceLocation());
   }
 };
 const char TargetNodeTraits<clang::CXXCtorInitializer>::kName[] = "initializer";
 
 template <typename DeclNode, typename TargetNode>
 class RewriterBase : public MatchFinder::MatchCallback {
  public:
   explicit RewriterBase(Replacements* replacements)
       : replacements_(replacements) {}
@@ skipping 161 matching lines @@
   VarDeclRewriter var_decl_rewriter(&replacements);
   match_finder.addMatcher(var_decl_matcher, &var_decl_rewriter);
 
   // Field and variable references ========
   // Given
   //   bool x = true;
   //   if (x) {
   //     ...
   //   }
   // matches |x| in if (x).
-  auto member_matcher = id("expr", memberExpr(member(field_decl_matcher)));
+  auto member_matcher = id(
+      "expr",
+      memberExpr(
+          member(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(isDefaulted())))));
   auto decl_ref_matcher = id("expr", declRefExpr(to(var_decl_matcher)));
 
   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);
 
   // Non-method function declarations ========
   // Given
@@ skipping 95 matching lines @@
 
   // Initializers ========
   // Given
   //   struct S {
   //     int x;
   //     S() : x(2) {}
   //   };
   // matches each initializer in the constructor for S.
   auto constructor_initializer_matcher =
       cxxConstructorDecl(forEachConstructorInitializer(
-          id("initializer", cxxCtorInitializer(forField(field_decl_matcher)))));
+          id("initializer",
+             cxxCtorInitializer(forField(field_decl_matcher), isWritten()))));
 
   ConstructorInitializerRewriter constructor_initializer_rewriter(
       &replacements);
   match_finder.addMatcher(constructor_initializer_matcher,
                           &constructor_initializer_rewriter);
 
   std::unique_ptr<clang::tooling::FrontendActionFactory> factory =
       clang::tooling::newFrontendActionFactory(&match_finder);
   int result = tool.run(factory.get());
   if (result != 0)
@@ skipping 35 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;
 }