Fix extra clang tools build.

tools/clang/rewrite_scoped_refptr/RewriteScopedRefptr.cpp

 // Copyright (c) 2013 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.
 //
 // This implements a Clang tool to rewrite all instances of
 // scoped_refptr<T>'s implicit cast to T (operator T*) to an explicit call to
 // the .get() method.
 
 #include <assert.h>
 #include <algorithm>
 #include <memory>
 #include <string>
 
 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchers.h"
 #include "clang/ASTMatchers/ASTMatchersMacros.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Frontend/FrontendActions.h"
 #include "clang/Lex/Lexer.h"
 #include "clang/Tooling/CommonOptionsParser.h"
 #include "clang/Tooling/Refactoring.h"
 #include "clang/Tooling/Tooling.h"
 #include "llvm/Support/CommandLine.h"
-#include "llvm/support/TargetSelect.h"
+#include "llvm/Support/TargetSelect.h"
 
 using namespace clang::ast_matchers;
 using clang::tooling::CommonOptionsParser;
 using clang::tooling::Replacement;
 using clang::tooling::Replacements;
 using llvm::StringRef;
 
 namespace clang {
 namespace ast_matchers {
 
@@ skipping 225 matching lines @@
   llvm::InitializeNativeTarget();
   llvm::InitializeNativeTargetAsmParser();
   llvm::cl::OptionCategory category("Remove scoped_refptr conversions");
   CommonOptionsParser options(argc, argv, category);
   clang::tooling::ClangTool tool(options.getCompilations(),
                                  options.getSourcePathList());
 
   MatchFinder match_finder;
   Replacements replacements;
 
-  auto is_scoped_refptr = recordDecl(isSameOrDerivedFrom("::scoped_refptr"),
-                                     isTemplateInstantiation());
+  auto is_scoped_refptr = cxxRecordDecl(isSameOrDerivedFrom("::scoped_refptr"),
+                                        isTemplateInstantiation());
 
   // Finds all calls to conversion operator member function. This catches calls
   // to "operator T*", "operator Testable", and "operator bool" equally.
-  auto base_matcher = memberCallExpr(thisPointerType(is_scoped_refptr),
-                                     callee(conversionDecl()),
-                                     on(id("arg", expr())));
+  auto base_matcher =
+      cxxMemberCallExpr(thisPointerType(is_scoped_refptr),
+                        callee(conversionDecl()), on(id("arg", expr())));
 
   // The heuristic for whether or not converting a temporary is 'unsafe'. An
   // unsafe conversion is one where a temporary scoped_refptr<T> is converted to
   // another type. The matcher provides an exception for a temporary
   // scoped_refptr that is the result of an operator call. In this case, assume
   // that it's the result of an iterator dereference, and the container itself
   // retains the necessary reference, since this is a common idiom to see in
   // loop bodies.
   auto is_unsafe_temporary_conversion =
-      on(bindTemporaryExpr(unless(has(operatorCallExpr()))));
+      on(cxxBindTemporaryExpr(unless(has(cxxOperatorCallExpr()))));
 
   // Returning a scoped_refptr<T> as a T* is considered unsafe if either are
   // true:
   // - The scoped_refptr<T> is a temporary.
   // - The scoped_refptr<T> has local lifetime.
   auto returned_as_raw_ptr = hasParent(
       returnStmt(hasAncestor(id("fn", functionDecl(returns(pointerType()))))));
   // This matcher intentionally matches more than it should. For example, this
   // will match:
   //   scoped_refptr<Foo>& foo = some_other_foo;
@@ skipping 16 matching lines @@
       implicitCastExpr(hasImplicitDestinationType(isBoolean()));
 
   // Avoid converting calls to of "operator Testable" -> "bool" and calls of
   // "operator T*" -> "bool".
   auto bool_conversion_matcher = hasParent(
       expr(anyOf(implicit_to_bool, expr(hasParent(implicit_to_bool)))));
 
   auto is_logging_helper =
       functionDecl(anyOf(hasName("CheckEQImpl"), hasName("CheckNEImpl")));
   auto is_gtest_helper = functionDecl(
-      anyOf(methodDecl(ofClass(recordDecl(isSameOrDerivedFrom(
-                           hasName("::testing::internal::EqHelper")))),
-                       hasName("Compare")),
+      anyOf(cxxMethodDecl(ofClass(cxxRecordDecl(isSameOrDerivedFrom(
+                              hasName("::testing::internal::EqHelper")))),
+                          hasName("Compare")),
             hasName("::testing::internal::CmpHelperNE")));
-  auto is_gtest_assertion_result_ctor = constructorDecl(ofClass(
-      recordDecl(isSameOrDerivedFrom(hasName("::testing::AssertionResult")))));
+  auto is_gtest_assertion_result_ctor =
+      cxxConstructorDecl(ofClass(cxxRecordDecl(
+          isSameOrDerivedFrom(hasName("::testing::AssertionResult")))));
 
   // Find all calls to an operator overload that are 'safe'.
   //
   // All bool conversions will be handled with the Testable trick, but that
   // can only be used once "operator T*" is removed, since otherwise it leaves
   // the call ambiguous.
   GetRewriterCallback get_callback(&replacements);
   match_finder.addMatcher(
-      memberCallExpr(
+      cxxMemberCallExpr(
           base_matcher,
           // Excluded since the conversion may be unsafe.
           unless(anyOf(is_unsafe_temporary_conversion, is_unsafe_return)),
           // Excluded since the conversion occurs inside a helper function that
           // the macro wraps. Letting this callback handle the rewrite would
           // result in an incorrect replacement that changes the helper function
           // itself. Instead, the right replacement is to rewrite the macro's
           // arguments.
-          unless(hasAncestor(decl(anyOf(is_logging_helper,
-                                        is_gtest_helper,
+          unless(hasAncestor(decl(anyOf(is_logging_helper, is_gtest_helper,
                                         is_gtest_assertion_result_ctor))))),
       &get_callback);
 
   // Find temporary scoped_refptr<T>'s being unsafely assigned to a T*.
   VarRewriterCallback var_callback(&replacements);
   auto initialized_with_temporary = ignoringImpCasts(exprWithCleanups(
-      has(memberCallExpr(base_matcher, is_unsafe_temporary_conversion))));
+      has(cxxMemberCallExpr(base_matcher, is_unsafe_temporary_conversion))));
   match_finder.addMatcher(id("var",
                              varDecl(hasInitializer(initialized_with_temporary),
                                      hasType(pointerType()))),
                           &var_callback);
   match_finder.addMatcher(
-      constructorDecl(forEachConstructorInitializer(
+      cxxConstructorDecl(forEachConstructorInitializer(
           allOf(withInitializer(initialized_with_temporary),
                 forField(id("var", fieldDecl(hasType(pointerType()))))))),
       &var_callback);
 
   // Rewrite functions that unsafely turn a scoped_refptr<T> into a T* when
   // returning a value.
   FunctionRewriterCallback fn_callback(&replacements);
-  match_finder.addMatcher(memberCallExpr(base_matcher, is_unsafe_return),
+  match_finder.addMatcher(cxxMemberCallExpr(base_matcher, is_unsafe_return),
                           &fn_callback);
 
   // Rewrite logging / gtest expressions that result in an implicit conversion.
   // Luckily, the matchers don't need to handle the case where one of the macro
   // arguments is NULL, such as:
   // CHECK_EQ(my_scoped_refptr, NULL)
   // because it simply doesn't compile--since NULL is actually of integral type,
   // this doesn't trigger scoped_refptr<T>'s implicit conversion. Since there is
   // no comparison overload for scoped_refptr<T> and int, this fails to compile.
   MacroRewriterCallback macro_callback(&replacements);
@@ skipping 19 matching lines @@
       &macro_callback);
   // ASSERT_TRUE/EXPECT_TRUE helpers. Note that this matcher doesn't need to
   // handle ASSERT_FALSE/EXPECT_FALSE, because it gets coerced to bool before
   // being passed as an argument to AssertionResult's constructor. As a result,
   // GetRewriterCallback handles this case properly since the conversion isn't
   // hidden inside AssertionResult, and the generated replacement properly
   // rewrites the macro argument.
   // However, the tool does need to handle the _TRUE counterparts, since the
   // conversion occurs inside the constructor in those cases.
   match_finder.addMatcher(
-      constructExpr(
+      cxxConstructExpr(
           argumentCountIs(2),
           hasArgument(0, id("expr", expr(hasType(is_scoped_refptr)))),
           hasDeclaration(is_gtest_assertion_result_ctor)),
       &macro_callback);
 
   std::unique_ptr<clang::tooling::FrontendActionFactory> factory =
       clang::tooling::newFrontendActionFactory(&match_finder);
   int result = tool.run(factory.get());
   if (result != 0)
     return result;
 
   // Serialization format is documented in tools/clang/scripts/run_tool.py
   llvm::outs() << "==== BEGIN EDITS ====\n";
   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;
 }