[ASTMatchers] Statically specify ownership of verifiers in tests. NFC

[courbet]

Summary

Statically specify ownership of verifiers in tests. NFC

[aaron.ballman]

LGTM! Thank you for the cleanup, this is more clear about the ownership semantics.

[courbet]

Thanks! Would you mind submitting this for me ?

[aaron.ballman]

Commit in r266986, thank you!

[courbet]

Thanks !

unittests/ASTMatchers/ASTMatchersTest.h

public:
   virtual void onEndOfTranslationUnit() {}
 };
 
 // If 'FindResultVerifier' is not NULL, sets *Verified to the result of
 // running 'FindResultVerifier' with the bound nodes as argument.
 // If 'FindResultVerifier' is NULL, sets *Verified to true when Run is called.
 class VerifyMatch : public MatchFinder::MatchCallback {
 public:
-  VerifyMatch(BoundNodesCallback *FindResultVerifier, bool *Verified)
-      : Verified(Verified), FindResultReviewer(FindResultVerifier) {}
+  VerifyMatch(std::unique_ptr<BoundNodesCallback> FindResultVerifier, bool *Verified)
+      : Verified(Verified), FindResultReviewer(std::move(FindResultVerifier)) {}
 
   void run(const MatchFinder::MatchResult &Result) override {
     if (FindResultReviewer != nullptr) {
       *Verified |= FindResultReviewer->run(&Result.Nodes, Result.Context);
     } else {
       *Verified = true;
     }
   }
 
   void onEndOfTranslationUnit() override {
     if (FindResultReviewer)
       FindResultReviewer->onEndOfTranslationUnit();
   }
 
 private:
   bool *const Verified;
-  BoundNodesCallback *const FindResultReviewer;
+  const std::unique_ptr<BoundNodesCallback> FindResultReviewer;
 };
 
 template <typename T>
 testing::AssertionResult matchesConditionally(
     const std::string &Code, const T &AMatcher, bool ExpectMatch,
     llvm::StringRef CompileArg,
     const FileContentMappings &VirtualMappedFiles = FileContentMappings(),
     const std::string &Filename = "input.cc") {

 testing::AssertionResult notMatchesWithCuda(const std::string &Code,
                                     const T &AMatcher) {
   return matchesConditionallyWithCuda(Code, AMatcher, false, "-std=c++11");
 }
 
 template <typename T>
 testing::AssertionResult
 matchAndVerifyResultConditionally(const std::string &Code, const T &AMatcher,
-                                  BoundNodesCallback *FindResultVerifier,
+                                  std::unique_ptr<BoundNodesCallback> FindResultVerifier,
                                   bool ExpectResult) {
-  std::unique_ptr<BoundNodesCallback> ScopedVerifier(FindResultVerifier);
   bool VerifiedResult = false;
   MatchFinder Finder;
-  VerifyMatch VerifyVerifiedResult(FindResultVerifier, &VerifiedResult);
+  VerifyMatch VerifyVerifiedResult(std::move(FindResultVerifier), &VerifiedResult);
   Finder.addMatcher(AMatcher, &VerifyVerifiedResult);
   std::unique_ptr<FrontendActionFactory> Factory(
       newFrontendActionFactory(&Finder));
   // Some tests use typeof, which is a gnu extension.
   std::vector<std::string> Args(1, "-std=gnu++98");
   if (!runToolOnCodeWithArgs(Factory->create(), Code, Args)) {
     return testing::AssertionFailure() << "Parsing error in \"" << Code << "\"";
   }
matchAndVerifyResultConditionally(const std::string &Code, const T &AMatcher,
   return testing::AssertionSuccess();
 }
 
 // FIXME: Find better names for these functions (or document what they
 // do more precisely).
 template <typename T>
 testing::AssertionResult
 matchAndVerifyResultTrue(const std::string &Code, const T &AMatcher,
-                         BoundNodesCallback *FindResultVerifier) {
+                         std::unique_ptr<BoundNodesCallback> FindResultVerifier) {
   return matchAndVerifyResultConditionally(
-      Code, AMatcher, FindResultVerifier, true);
+      Code, AMatcher, std::move(FindResultVerifier), true);
 }
 
 template <typename T>
 testing::AssertionResult
 matchAndVerifyResultFalse(const std::string &Code, const T &AMatcher,
-                          BoundNodesCallback *FindResultVerifier) {
+                          std::unique_ptr<BoundNodesCallback> FindResultVerifier) {
   return matchAndVerifyResultConditionally(
-      Code, AMatcher, FindResultVerifier, false);
+      Code, AMatcher, std::move(FindResultVerifier), false);
 }
 
 } // end namespace ast_matchers
 } // end namespace clang
 
 #endif  // LLVM_CLANG_UNITTESTS_AST_MATCHERS_AST_MATCHERS_TEST_H

unittests/ASTMatchers/ASTMatchersTest.cpp

TEST(HasDescendant, MatchesDescendantTypes) {
 
   EXPECT_TRUE(notMatches("void f() { float f = 2.0f; }",
                          stmt(hasDescendant(isInteger()))));
 
   EXPECT_TRUE(matchAndVerifyResultTrue(
       "void f() { int a; float c; int d; int e; }",
       functionDecl(forEachDescendant(
           varDecl(hasDescendant(isInteger())).bind("x"))),
-      new VerifyIdIsBoundTo<Decl>("x", 3)));
+      llvm::make_unique<VerifyIdIsBoundTo<Decl>>("x", 3)));
 }
 
 TEST(HasDescendant, MatchesDescendantsOfTypes) {
   EXPECT_TRUE(matches("void f() { int*** i; }",
                       qualType(hasDescendant(builtinType()))));
   EXPECT_TRUE(matches("void f() { int*** i; }",
                       qualType(hasDescendant(
                           pointerType(pointee(builtinType()))))));
   EXPECT_TRUE(matches("void f() { int*** i; }",
                       typeLoc(hasDescendant(loc(builtinType())))));
 
   EXPECT_TRUE(matchAndVerifyResultTrue(
       "void f() { int*** i; }",
       qualType(asString("int ***"), forEachDescendant(pointerType().bind("x"))),
-      new VerifyIdIsBoundTo<Type>("x", 2)));
+      llvm::make_unique<VerifyIdIsBoundTo<Type>>("x", 2)));
 }
 
 TEST(Has, MatchesChildrenOfTypes) {
   EXPECT_TRUE(matches("int i;",
                       varDecl(hasName("i"), has(isInteger()))));
   EXPECT_TRUE(notMatches("int** i;",
                          varDecl(hasName("i"), has(isInteger()))));
   EXPECT_TRUE(matchAndVerifyResultTrue(
       "int (*f)(float, int);",
       qualType(functionType(), forEach(qualType(isInteger()).bind("x"))),
-      new VerifyIdIsBoundTo<QualType>("x", 2)));
+      llvm::make_unique<VerifyIdIsBoundTo<QualType>>("x", 2)));
 }
 
 TEST(Has, MatchesChildTypes) {
   EXPECT_TRUE(matches(
       "int* i;",
       varDecl(hasName("i"), hasType(qualType(has(builtinType()))))));
   EXPECT_TRUE(notMatches(
       "int* i;",
TEST(TypeMatcher, MatchesDeclTypes) {
   // UnresolvedUsingTypenameType -> UnresolvedUsingTypenameDecl
   EXPECT_TRUE(matches(Using, parmVarDecl(hasType(namedDecl(hasName("Foo"))))));
 }
 
 TEST(Matcher, BindMatchedNodes) {
   DeclarationMatcher ClassX = has(recordDecl(hasName("::X")).bind("x"));
 
   EXPECT_TRUE(matchAndVerifyResultTrue("class X {};",
-      ClassX, new VerifyIdIsBoundTo<CXXRecordDecl>("x")));
+      ClassX, llvm::make_unique<VerifyIdIsBoundTo<CXXRecordDecl>>("x")));
 
   EXPECT_TRUE(matchAndVerifyResultFalse("class X {};",
-      ClassX, new VerifyIdIsBoundTo<CXXRecordDecl>("other-id")));
+      ClassX, llvm::make_unique<VerifyIdIsBoundTo<CXXRecordDecl>>("other-id")));
 
   TypeMatcher TypeAHasClassB = hasDeclaration(
       recordDecl(hasName("A"), has(recordDecl(hasName("B")).bind("b"))));
 
   EXPECT_TRUE(matchAndVerifyResultTrue("class A { public: A *a; class B {}; };",
       TypeAHasClassB,
-      new VerifyIdIsBoundTo<Decl>("b")));
+      llvm::make_unique<VerifyIdIsBoundTo<Decl>>("b")));
 
   StatementMatcher MethodX =
       callExpr(callee(cxxMethodDecl(hasName("x")))).bind("x");
 
   EXPECT_TRUE(matchAndVerifyResultTrue("class A { void x() { x(); } };",
       MethodX,
-      new VerifyIdIsBoundTo<CXXMemberCallExpr>("x")));
+      llvm::make_unique<VerifyIdIsBoundTo<CXXMemberCallExpr>>("x")));
 }
 
 TEST(Matcher, BindTheSameNameInAlternatives) {
   StatementMatcher matcher = anyOf(
       binaryOperator(hasOperatorName("+"),
                      hasLHS(expr().bind("x")),
                      hasRHS(integerLiteral(equals(0)))),
       binaryOperator(hasOperatorName("+"),
                      hasLHS(integerLiteral(equals(0))),
                      hasRHS(expr().bind("x"))));
 
   EXPECT_TRUE(matchAndVerifyResultTrue(
       // The first branch of the matcher binds x to 0 but then fails.
       // The second branch binds x to f() and succeeds.
       "int f() { return 0 + f(); }",
       matcher,
-      new VerifyIdIsBoundTo<CallExpr>("x")));
+      llvm::make_unique<VerifyIdIsBoundTo<CallExpr>>("x")));
 }
 
 TEST(Matcher, BindsIDForMemoizedResults) {
   // Using the same matcher in two match expressions will make memoization
   // kick in.
   DeclarationMatcher ClassX = recordDecl(hasName("X")).bind("x");
   EXPECT_TRUE(matchAndVerifyResultTrue(
       "class A { class B { class X {}; }; };",
       DeclarationMatcher(anyOf(
           recordDecl(hasName("A"), hasDescendant(ClassX)),
           recordDecl(hasName("B"), hasDescendant(ClassX)))),
-      new VerifyIdIsBoundTo<Decl>("x", 2)));
+      llvm::make_unique<VerifyIdIsBoundTo<Decl>>("x", 2)));
 }
 
 TEST(HasDeclaration, HasDeclarationOfEnumType) {
   EXPECT_TRUE(matches("enum X {}; void y(X *x) { x; }",
                       expr(hasType(pointsTo(
                           qualType(hasDeclaration(enumDecl(hasName("X")))))))));
 }
 

 }
 
 TEST(Matcher, NestedOverloadedOperatorCalls) {
   EXPECT_TRUE(matchAndVerifyResultTrue(
       "class Y { }; "
       "Y& operator&&(Y& x, Y& y) { return x; }; "
       "Y a; Y b; Y c; Y d = a && b && c;",
       cxxOperatorCallExpr(hasOverloadedOperatorName("&&")).bind("x"),
-      new VerifyIdIsBoundTo<CXXOperatorCallExpr>("x", 2)));
+      llvm::make_unique<VerifyIdIsBoundTo<CXXOperatorCallExpr>>("x", 2)));
   EXPECT_TRUE(matches("class Y { }; "
                       "Y& operator&&(Y& x, Y& y) { return x; }; "
                       "Y a; Y b; Y c; Y d = a && b && c;",
                       cxxOperatorCallExpr(hasParent(cxxOperatorCallExpr()))));
   EXPECT_TRUE(
       matches("class Y { }; "
               "Y& operator&&(Y& x, Y& y) { return x; }; "
               "Y a; Y b; Y c; Y d = a && b && c;",
TEST(ForEachArgumentWithParam, MatchesCXXMemberCallExpr) {
   EXPECT_TRUE(matchAndVerifyResultTrue(
       "struct S {"
       "  const S& operator[](int i) { return *this; }"
       "};"
       "void f(S S1) {"
       "  int y = 1;"
       "  S1[y];"
       "}",
-      CallExpr, new VerifyIdIsBoundTo<ParmVarDecl>("param", 1)));
+      CallExpr, llvm::make_unique<VerifyIdIsBoundTo<ParmVarDecl>>("param", 1)));
 
   StatementMatcher CallExpr2 =
       callExpr(forEachArgumentWithParam(ArgumentY, IntParam));
   EXPECT_TRUE(matchAndVerifyResultTrue(
       "struct S {"
       "  static void g(int i);"
       "};"
       "void f() {"
       "  int y = 1;"
       "  S::g(y);"
       "}",
-      CallExpr2, new VerifyIdIsBoundTo<ParmVarDecl>("param", 1)));
+      CallExpr2, llvm::make_unique<VerifyIdIsBoundTo<ParmVarDecl>>("param", 1)));
 }
 
 TEST(ForEachArgumentWithParam, MatchesCallExpr) {
   StatementMatcher ArgumentY =
       declRefExpr(to(varDecl(hasName("y")))).bind("arg");
   DeclarationMatcher IntParam = parmVarDecl(hasType(isInteger())).bind("param");
   StatementMatcher CallExpr =
       callExpr(forEachArgumentWithParam(ArgumentY, IntParam));
 
   EXPECT_TRUE(
       matchAndVerifyResultTrue("void f(int i) { int y; f(y); }", CallExpr,
-                               new VerifyIdIsBoundTo<ParmVarDecl>("param")));
+                               llvm::make_unique<VerifyIdIsBoundTo<ParmVarDecl>>(
+                                   "param")));
   EXPECT_TRUE(
       matchAndVerifyResultTrue("void f(int i) { int y; f(y); }", CallExpr,
-                               new VerifyIdIsBoundTo<DeclRefExpr>("arg")));
+                               llvm::make_unique<VerifyIdIsBoundTo<DeclRefExpr>>(
+                                   "arg")));
 
   EXPECT_TRUE(matchAndVerifyResultTrue(
       "void f(int i, int j) { int y; f(y, y); }", CallExpr,
-      new VerifyIdIsBoundTo<ParmVarDecl>("param", 2)));
+      llvm::make_unique<VerifyIdIsBoundTo<ParmVarDecl>>("param", 2)));
   EXPECT_TRUE(matchAndVerifyResultTrue(
       "void f(int i, int j) { int y; f(y, y); }", CallExpr,
-      new VerifyIdIsBoundTo<DeclRefExpr>("arg", 2)));
+      llvm::make_unique<VerifyIdIsBoundTo<DeclRefExpr>>("arg", 2)));
 }
 
 TEST(ForEachArgumentWithParam, MatchesConstructExpr) {
   StatementMatcher ArgumentY =
       declRefExpr(to(varDecl(hasName("y")))).bind("arg");
   DeclarationMatcher IntParam = parmVarDecl(hasType(isInteger())).bind("param");
   StatementMatcher ConstructExpr =
       cxxConstructExpr(forEachArgumentWithParam(ArgumentY, IntParam));
 
   EXPECT_TRUE(matchAndVerifyResultTrue(
       "struct C {"
       "  C(int i) {}"
       "};"
       "int y = 0;"
       "C Obj(y);",
-      ConstructExpr, new VerifyIdIsBoundTo<ParmVarDecl>("param")));
+      ConstructExpr,
+      llvm::make_unique<VerifyIdIsBoundTo<ParmVarDecl>>("param")));
 }
 
 TEST(ForEachArgumentWithParam, HandlesBoundNodesForNonMatches) {
   EXPECT_TRUE(matchAndVerifyResultTrue(
       "void g(int i, int j) {"
       "  int a;"
       "  int b;"
       "  int c;"
       "  g(a, 0);"
       "  g(a, b);"
       "  g(0, b);"
       "}",
       functionDecl(
           forEachDescendant(varDecl().bind("v")),
           forEachDescendant(callExpr(forEachArgumentWithParam(
               declRefExpr(to(decl(equalsBoundNode("v")))), parmVarDecl())))),
-      new VerifyIdIsBoundTo<VarDecl>("v", 4)));
+      llvm::make_unique<VerifyIdIsBoundTo<VarDecl>>("v", 4)));
 }
 
 TEST(Matcher, ArgumentCount) {
   StatementMatcher Call1Arg = callExpr(argumentCountIs(1));
 
   EXPECT_TRUE(matches("void x(int) { x(0); }", Call1Arg));
   EXPECT_TRUE(matches("class X { void x(int) { x(0); } };", Call1Arg));
   EXPECT_TRUE(notMatches("void x(int, int) { x(0, 0); }", Call1Arg));
AST_MATCHER_P(Decl, just, internal::Matcher<Decl>, AMatcher) {
   // bound_nodes_builder, and the parameter named 'AMatcher'.
   return AMatcher.matches(Node, Finder, Builder);
 }
 
 TEST(AstMatcherPMacro, Works) {
   DeclarationMatcher HasClassB = just(has(recordDecl(hasName("B")).bind("b")));
 
   EXPECT_TRUE(matchAndVerifyResultTrue("class A { class B {}; };",
-      HasClassB, new VerifyIdIsBoundTo<Decl>("b")));
+      HasClassB, llvm::make_unique<VerifyIdIsBoundTo<Decl>>("b")));
 
   EXPECT_TRUE(matchAndVerifyResultFalse("class A { class B {}; };",
-      HasClassB, new VerifyIdIsBoundTo<Decl>("a")));
+      HasClassB, llvm::make_unique<VerifyIdIsBoundTo<Decl>>("a")));
 
   EXPECT_TRUE(matchAndVerifyResultFalse("class A { class C {}; };",
-      HasClassB, new VerifyIdIsBoundTo<Decl>("b")));
+      HasClassB, llvm::make_unique<VerifyIdIsBoundTo<Decl>>("b")));
 }
 
 AST_POLYMORPHIC_MATCHER_P(polymorphicHas,
                           AST_POLYMORPHIC_SUPPORTED_TYPES(Decl, Stmt),
                           internal::Matcher<Decl>, AMatcher) {
   return Finder->matchesChildOf(
       Node, AMatcher, Builder,
       ASTMatchFinder::TK_IgnoreImplicitCastsAndParentheses,
       ASTMatchFinder::BK_First);
 }
 
 TEST(AstPolymorphicMatcherPMacro, Works) {
   DeclarationMatcher HasClassB =
       polymorphicHas(recordDecl(hasName("B")).bind("b"));
 
   EXPECT_TRUE(matchAndVerifyResultTrue("class A { class B {}; };",
-      HasClassB, new VerifyIdIsBoundTo<Decl>("b")));
+      HasClassB, llvm::make_unique<VerifyIdIsBoundTo<Decl>>("b")));
 
   EXPECT_TRUE(matchAndVerifyResultFalse("class A { class B {}; };",
-      HasClassB, new VerifyIdIsBoundTo<Decl>("a")));
+      HasClassB, llvm::make_unique<VerifyIdIsBoundTo<Decl>>("a")));
 
   EXPECT_TRUE(matchAndVerifyResultFalse("class A { class C {}; };",
-      HasClassB, new VerifyIdIsBoundTo<Decl>("b")));
+      HasClassB, llvm::make_unique<VerifyIdIsBoundTo<Decl>>("b")));
 
   StatementMatcher StatementHasClassB =
       polymorphicHas(recordDecl(hasName("B")));
 
   EXPECT_TRUE(matches("void x() { class B {}; }", StatementHasClassB));
 }
 
 TEST(For, FindsForLoops) {
EXPECT_TRUE(notMatches("void x() { switch(42) { case 1+1: case 2+2:; } }",
                          switchStmt(forEachSwitchCase(
                              caseStmt(hasCaseConstant(integerLiteral()))))));
   EXPECT_TRUE(notMatches("void x() { switch(42) { case 1 ... 2:; } }",
                          switchStmt(forEachSwitchCase(
                              caseStmt(hasCaseConstant(integerLiteral()))))));
   EXPECT_TRUE(matchAndVerifyResultTrue(
       "void x() { switch (42) { case 1: case 2: case 3: default:; } }",
       switchStmt(forEachSwitchCase(caseStmt().bind("x"))),
-      new VerifyIdIsBoundTo<CaseStmt>("x", 3)));
+      llvm::make_unique<VerifyIdIsBoundTo<CaseStmt>>("x", 3)));
 }
 
 TEST(ForEachConstructorInitializer, MatchesInitializers) {
   EXPECT_TRUE(matches(
       "struct X { X() : i(42), j(42) {} int i, j; };",
       cxxConstructorDecl(forEachConstructorInitializer(cxxCtorInitializer()))));
 }
 
TEST(HasConditionVariableStatement, MatchesConditionVariables) {
   EXPECT_TRUE(matches(
       "void x() { if(int* a = 0) {} }",
       ifStmt(hasConditionVariableStatement(declStmt()))));
 }
 
 TEST(ForEach, BindsOneNode) {
   EXPECT_TRUE(matchAndVerifyResultTrue("class C { int x; };",
       recordDecl(hasName("C"), forEach(fieldDecl(hasName("x")).bind("x"))),
-      new VerifyIdIsBoundTo<FieldDecl>("x", 1)));
+      llvm::make_unique<VerifyIdIsBoundTo<FieldDecl>>("x", 1)));
 }
 
 TEST(ForEach, BindsMultipleNodes) {
   EXPECT_TRUE(matchAndVerifyResultTrue("class C { int x; int y; int z; };",
       recordDecl(hasName("C"), forEach(fieldDecl().bind("f"))),
-      new VerifyIdIsBoundTo<FieldDecl>("f", 3)));
+      llvm::make_unique<VerifyIdIsBoundTo<FieldDecl>>("f", 3)));
 }
 
 TEST(ForEach, BindsRecursiveCombinations) {
   EXPECT_TRUE(matchAndVerifyResultTrue(
       "class C { class D { int x; int y; }; class E { int y; int z; }; };",
       recordDecl(hasName("C"),
                  forEach(recordDecl(forEach(fieldDecl().bind("f"))))),
-      new VerifyIdIsBoundTo<FieldDecl>("f", 4)));
+      llvm::make_unique<VerifyIdIsBoundTo<FieldDecl>>("f", 4)));
 }
 
 TEST(ForEachDescendant, BindsOneNode) {
   EXPECT_TRUE(matchAndVerifyResultTrue("class C { class D { int x; }; };",
       recordDecl(hasName("C"),
                  forEachDescendant(fieldDecl(hasName("x")).bind("x"))),
-      new VerifyIdIsBoundTo<FieldDecl>("x", 1)));
+      llvm::make_unique<VerifyIdIsBoundTo<FieldDecl>>("x", 1)));
 }
 
 TEST(ForEachDescendant, NestedForEachDescendant) {
   DeclarationMatcher m = recordDecl(
       isDefinition(), decl().bind("x"), hasName("C"));
   EXPECT_TRUE(matchAndVerifyResultTrue(
     "class A { class B { class C {}; }; };",
     recordDecl(hasName("A"), anyOf(m, forEachDescendant(m))),
-    new VerifyIdIsBoundTo<Decl>("x", "C")));
+    llvm::make_unique<VerifyIdIsBoundTo<Decl>>("x", "C")));
 
   // Check that a partial match of 'm' that binds 'x' in the
   // first part of anyOf(m, anything()) will not overwrite the
   // binding created by the earlier binding in the hasDescendant.
   EXPECT_TRUE(matchAndVerifyResultTrue(
       "class A { class B { class C {}; }; };",
       recordDecl(hasName("A"), allOf(hasDescendant(m), anyOf(m, anything()))),
-      new VerifyIdIsBoundTo<Decl>("x", "C")));
+      llvm::make_unique<VerifyIdIsBoundTo<Decl>>("x", "C")));
 }
 
 TEST(ForEachDescendant, BindsMultipleNodes) {
   EXPECT_TRUE(matchAndVerifyResultTrue(
       "class C { class D { int x; int y; }; "
       "          class E { class F { int y; int z; }; }; };",
       recordDecl(hasName("C"), forEachDescendant(fieldDecl().bind("f"))),
-      new VerifyIdIsBoundTo<FieldDecl>("f", 4)));
+      llvm::make_unique<VerifyIdIsBoundTo<FieldDecl>>("f", 4)));
 }
 
 TEST(ForEachDescendant, BindsRecursiveCombinations) {
   EXPECT_TRUE(matchAndVerifyResultTrue(
       "class C { class D { "
       "          class E { class F { class G { int y; int z; }; }; }; }; };",
       recordDecl(hasName("C"), forEachDescendant(recordDecl(
           forEachDescendant(fieldDecl().bind("f"))))),
-      new VerifyIdIsBoundTo<FieldDecl>("f", 8)));
+      llvm::make_unique<VerifyIdIsBoundTo<FieldDecl>>("f", 8)));
 }
 
 TEST(ForEachDescendant, BindsCombinations) {
   EXPECT_TRUE(matchAndVerifyResultTrue(
       "void f() { if(true) {} if (true) {} while (true) {} if (true) {} while "
       "(true) {} }",
       compoundStmt(forEachDescendant(ifStmt().bind("if")),
                    forEachDescendant(whileStmt().bind("while"))),
-      new VerifyIdIsBoundTo<IfStmt>("if", 6)));
+      llvm::make_unique<VerifyIdIsBoundTo<IfStmt>>("if", 6)));
 }
 
 TEST(Has, DoesNotDeleteBindings) {
   EXPECT_TRUE(matchAndVerifyResultTrue(
       "class X { int a; };", recordDecl(decl().bind("x"), has(fieldDecl())),
-      new VerifyIdIsBoundTo<Decl>("x", 1)));
+      llvm::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
 }
 
 TEST(LoopingMatchers, DoNotOverwritePreviousMatchResultOnFailure) {
   // Those matchers cover all the cases where an inner matcher is called
   // and there is not a 1:1 relationship between the match of the outer
   // matcher and the match of the inner matcher.
   // The pattern to look for is:
   //   ... return InnerMatcher.matches(...); ...
TEST(LoopingMatchers, DoNotOverwritePreviousMatchResultOnFailure) {
   //   would need to return false; for hasAncestor, it means that not
   //   the direct parent matches the inner matcher.
 
   EXPECT_TRUE(matchAndVerifyResultTrue(
       "class X { int y; };",
       recordDecl(
           recordDecl().bind("x"), hasName("::X"),
           anyOf(forEachDescendant(recordDecl(hasName("Y"))), anything())),
-      new VerifyIdIsBoundTo<CXXRecordDecl>("x", 1)));
+      llvm::make_unique<VerifyIdIsBoundTo<CXXRecordDecl>>("x", 1)));
   EXPECT_TRUE(matchAndVerifyResultTrue(
       "class X {};", recordDecl(recordDecl().bind("x"), hasName("::X"),
                                 anyOf(unless(anything()), anything())),
-      new VerifyIdIsBoundTo<CXXRecordDecl>("x", 1)));
+      llvm::make_unique<VerifyIdIsBoundTo<CXXRecordDecl>>("x", 1)));
   EXPECT_TRUE(matchAndVerifyResultTrue(
       "template<typename T1, typename T2> class X {}; X<float, int> x;",
       classTemplateSpecializationDecl(
           decl().bind("x"),
           hasAnyTemplateArgument(refersToType(asString("int")))),
-      new VerifyIdIsBoundTo<Decl>("x", 1)));
+      llvm::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
   EXPECT_TRUE(matchAndVerifyResultTrue(
       "class X { void f(); void g(); };",
       cxxRecordDecl(decl().bind("x"), hasMethod(hasName("g"))),
-      new VerifyIdIsBoundTo<Decl>("x", 1)));
+      llvm::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
   EXPECT_TRUE(matchAndVerifyResultTrue(
       "class X { X() : a(1), b(2) {} double a; int b; };",
       recordDecl(decl().bind("x"),
                  has(cxxConstructorDecl(
                      hasAnyConstructorInitializer(forField(hasName("b")))))),
-      new VerifyIdIsBoundTo<Decl>("x", 1)));
+      llvm::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
   EXPECT_TRUE(matchAndVerifyResultTrue(
       "void x(int, int) { x(0, 42); }",
       callExpr(expr().bind("x"), hasAnyArgument(integerLiteral(equals(42)))),
-      new VerifyIdIsBoundTo<Expr>("x", 1)));
+      llvm::make_unique<VerifyIdIsBoundTo<Expr>>("x", 1)));
   EXPECT_TRUE(matchAndVerifyResultTrue(
       "void x(int, int y) {}",
       functionDecl(decl().bind("x"), hasAnyParameter(hasName("y"))),
-      new VerifyIdIsBoundTo<Decl>("x", 1)));
+      llvm::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
   EXPECT_TRUE(matchAndVerifyResultTrue(
       "void x() { return; if (true) {} }",
       functionDecl(decl().bind("x"),
                    has(compoundStmt(hasAnySubstatement(ifStmt())))),
-      new VerifyIdIsBoundTo<Decl>("x", 1)));
+      llvm::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
   EXPECT_TRUE(matchAndVerifyResultTrue(
       "namespace X { void b(int); void b(); }"
       "using X::b;",
       usingDecl(decl().bind("x"), hasAnyUsingShadowDecl(hasTargetDecl(
                                       functionDecl(parameterCountIs(1))))),
-      new VerifyIdIsBoundTo<Decl>("x", 1)));
+      llvm::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
   EXPECT_TRUE(matchAndVerifyResultTrue(
       "class A{}; class B{}; class C : B, A {};",
       cxxRecordDecl(decl().bind("x"), isDerivedFrom("::A")),
-      new VerifyIdIsBoundTo<Decl>("x", 1)));
+      llvm::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
   EXPECT_TRUE(matchAndVerifyResultTrue(
       "class A{}; typedef A B; typedef A C; typedef A D;"
       "class E : A {};",
       cxxRecordDecl(decl().bind("x"), isDerivedFrom("C")),
-      new VerifyIdIsBoundTo<Decl>("x", 1)));
+      llvm::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
   EXPECT_TRUE(matchAndVerifyResultTrue(
       "class A { class B { void f() {} }; };",
       functionDecl(decl().bind("x"), hasAncestor(recordDecl(hasName("::A")))),
-      new VerifyIdIsBoundTo<Decl>("x", 1)));
+      llvm::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
   EXPECT_TRUE(matchAndVerifyResultTrue(
       "template <typename T> struct A { struct B {"
       "  void f() { if(true) {} }"
       "}; };"
       "void t() { A<int>::B b; b.f(); }",
       ifStmt(stmt().bind("x"), hasAncestor(recordDecl(hasName("::A")))),
-      new VerifyIdIsBoundTo<Stmt>("x", 2)));
+      llvm::make_unique<VerifyIdIsBoundTo<Stmt>>("x", 2)));
   EXPECT_TRUE(matchAndVerifyResultTrue(
       "class A {};",
       recordDecl(hasName("::A"), decl().bind("x"), unless(hasName("fooble"))),
-      new VerifyIdIsBoundTo<Decl>("x", 1)));
+      llvm::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
   EXPECT_TRUE(matchAndVerifyResultTrue(
       "class A { A() : s(), i(42) {} const char *s; int i; };",
       cxxConstructorDecl(hasName("::A::A"), decl().bind("x"),
                          forEachConstructorInitializer(forField(hasName("i")))),
-      new VerifyIdIsBoundTo<Decl>("x", 1)));
+      llvm::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
 }
 
 TEST(ForEachDescendant, BindsCorrectNodes) {
   EXPECT_TRUE(matchAndVerifyResultTrue(
       "class C { void f(); int i; };",
       recordDecl(hasName("C"), forEachDescendant(decl().bind("decl"))),
-      new VerifyIdIsBoundTo<FieldDecl>("decl", 1)));
+      llvm::make_unique<VerifyIdIsBoundTo<FieldDecl>>("decl", 1)));
   EXPECT_TRUE(matchAndVerifyResultTrue(
       "class C { void f() {} int i; };",
       recordDecl(hasName("C"), forEachDescendant(decl().bind("decl"))),
-      new VerifyIdIsBoundTo<FunctionDecl>("decl", 1)));
+      llvm::make_unique<VerifyIdIsBoundTo<FunctionDecl>>("decl", 1)));
 }
 
 TEST(FindAll, BindsNodeOnMatch) {
   EXPECT_TRUE(matchAndVerifyResultTrue(
       "class A {};",
       recordDecl(hasName("::A"), findAll(recordDecl(hasName("::A")).bind("v"))),
-      new VerifyIdIsBoundTo<CXXRecordDecl>("v", 1)));
+      llvm::make_unique<VerifyIdIsBoundTo<CXXRecordDecl>>("v", 1)));
 }
 
 TEST(FindAll, BindsDescendantNodeOnMatch) {
   EXPECT_TRUE(matchAndVerifyResultTrue(
       "class A { int a; int b; };",
       recordDecl(hasName("::A"), findAll(fieldDecl().bind("v"))),
-      new VerifyIdIsBoundTo<FieldDecl>("v", 2)));
+      llvm::make_unique<VerifyIdIsBoundTo<FieldDecl>>("v", 2)));
 }
 
 TEST(FindAll, BindsNodeAndDescendantNodesOnOneMatch) {
   EXPECT_TRUE(matchAndVerifyResultTrue(
       "class A { int a; int b; };",
       recordDecl(hasName("::A"),
                  findAll(decl(anyOf(recordDecl(hasName("::A")).bind("v"),
                                     fieldDecl().bind("v"))))),
-      new VerifyIdIsBoundTo<Decl>("v", 3)));
+      llvm::make_unique<VerifyIdIsBoundTo<Decl>>("v", 3)));
 
   EXPECT_TRUE(matchAndVerifyResultTrue(
       "class A { class B {}; class C {}; };",
       recordDecl(hasName("::A"), findAll(recordDecl(isDefinition()).bind("v"))),
-      new VerifyIdIsBoundTo<CXXRecordDecl>("v", 3)));
+      llvm::make_unique<VerifyIdIsBoundTo<CXXRecordDecl>>("v", 3)));
 }
 
 TEST(EachOf, TriggersForEachMatch) {
   EXPECT_TRUE(matchAndVerifyResultTrue(
       "class A { int a; int b; };",
       recordDecl(eachOf(has(fieldDecl(hasName("a")).bind("v")),
                         has(fieldDecl(hasName("b")).bind("v")))),
-      new VerifyIdIsBoundTo<FieldDecl>("v", 2)));
+      llvm::make_unique<VerifyIdIsBoundTo<FieldDecl>>("v", 2)));
 }
 
 TEST(EachOf, BehavesLikeAnyOfUnlessBothMatch) {
   EXPECT_TRUE(matchAndVerifyResultTrue(
       "class A { int a; int c; };",
       recordDecl(eachOf(has(fieldDecl(hasName("a")).bind("v")),
                         has(fieldDecl(hasName("b")).bind("v")))),
-      new VerifyIdIsBoundTo<FieldDecl>("v", 1)));
+      llvm::make_unique<VerifyIdIsBoundTo<FieldDecl>>("v", 1)));
   EXPECT_TRUE(matchAndVerifyResultTrue(
       "class A { int c; int b; };",
       recordDecl(eachOf(has(fieldDecl(hasName("a")).bind("v")),
                         has(fieldDecl(hasName("b")).bind("v")))),
-      new VerifyIdIsBoundTo<FieldDecl>("v", 1)));
+      llvm::make_unique<VerifyIdIsBoundTo<FieldDecl>>("v", 1)));
   EXPECT_TRUE(notMatches(
       "class A { int c; int d; };",
       recordDecl(eachOf(has(fieldDecl(hasName("a")).bind("v")),
                         has(fieldDecl(hasName("b")).bind("v"))))));
 }
 
 TEST(IsTemplateInstantiation, MatchesImplicitClassTemplateInstantiation) {
   // Make sure that we can both match the class by name (::X) and by the type
EXPECT_TRUE(matches(
       "void f() { if (true) { int x = 42; } }",
       integerLiteral(equals(42), hasAncestor(functionDecl(hasName("f"))))));
 }
 
 TEST(HasAncestor, BindsRecursiveCombinations) {
   EXPECT_TRUE(matchAndVerifyResultTrue(
       "class C { class D { class E { class F { int y; }; }; }; };",
       fieldDecl(hasAncestor(recordDecl(hasAncestor(recordDecl().bind("r"))))),
-      new VerifyIdIsBoundTo<CXXRecordDecl>("r", 1)));
+      llvm::make_unique<VerifyIdIsBoundTo<CXXRecordDecl>>("r", 1)));
 }
 
 TEST(HasAncestor, BindsCombinationsWithHasDescendant) {
   EXPECT_TRUE(matchAndVerifyResultTrue(
       "class C { class D { class E { class F { int y; }; }; }; };",
       fieldDecl(hasAncestor(
           decl(
             hasDescendant(recordDecl(isDefinition(),
                                      hasAncestor(recordDecl())))
           ).bind("d")
       )),
-      new VerifyIdIsBoundTo<CXXRecordDecl>("d", "E")));
+      llvm::make_unique<VerifyIdIsBoundTo<CXXRecordDecl>>("d", "E")));
 }
 
 TEST(HasAncestor, MatchesClosestAncestor) {
   EXPECT_TRUE(matchAndVerifyResultTrue(
       "template <typename T> struct C {"
       "  void f(int) {"
       "    struct I { void g(T) { int x; } } i; i.g(42);"
       "  }"
       "};"
       "template struct C<int>;",
       varDecl(hasName("x"),
               hasAncestor(functionDecl(hasParameter(
                   0, varDecl(hasType(asString("int"))))).bind("f"))).bind("v"),
-      new VerifyIdIsBoundTo<FunctionDecl>("f", "g", 2)));
+      llvm::make_unique<VerifyIdIsBoundTo<FunctionDecl>>("f", "g", 2)));
 }
 
 TEST(HasAncestor, MatchesInTemplateInstantiations) {
   EXPECT_TRUE(matches(
       "template <typename T> struct A { struct B { struct C { T t; }; }; }; "
       "A<int>::B::C a;",
       fieldDecl(hasType(asString("int")),
                 hasAncestor(recordDecl(hasName("A"))))));
bool run(const BoundNodes *Nodes, ASTContext *Context) override {
         }
       }
       return false;
     }
   };
   EXPECT_FALSE(matchAndVerifyResultTrue(
       "template <typename T> int Foo() { return 1 + 2; }\n"
       "int x = Foo<int>() + Foo<unsigned>();",
-      stmt().bind("node"), new HasDuplicateParents()));
+      stmt().bind("node"), llvm::make_unique<HasDuplicateParents>()));
 }
 
 TEST(TypeMatching, MatchesTypes) {
   EXPECT_TRUE(matches("struct S {};", qualType().bind("loc")));
 }
 
 TEST(TypeMatching, MatchesBool) {
   EXPECT_TRUE(matches("struct S { bool func(); };",

 
 TEST(TypeMatching, PointerTypes) {
   // FIXME: Reactive when these tests can be more specific (not matching
   // implicit code on certain platforms), likely when we have hasDescendant for
   // Types/TypeLocs.
   //EXPECT_TRUE(matchAndVerifyResultTrue(
   //    "int* a;",
   //    pointerTypeLoc(pointeeLoc(typeLoc().bind("loc"))),
-  //    new VerifyIdIsBoundTo<TypeLoc>("loc", 1)));
+  //    llvm::make_unique<VerifyIdIsBoundTo<TypeLoc>>("loc", 1)));
   //EXPECT_TRUE(matchAndVerifyResultTrue(
   //    "int* a;",
   //    pointerTypeLoc().bind("loc"),
-  //    new VerifyIdIsBoundTo<TypeLoc>("loc", 1)));
+  //    llvm::make_unique<VerifyIdIsBoundTo<TypeLoc>>("loc", 1)));
   EXPECT_TRUE(matches(
       "int** a;",
       loc(pointerType(pointee(qualType())))));
   EXPECT_TRUE(matches(
       "int** a;",
       loc(pointerType(pointee(pointerType())))));
   EXPECT_TRUE(matches(
       "int* b; int* * const a = &b;",
TEST(NNS, MatchesNamespaceDecls) {
   EXPECT_TRUE(notMatches("namespace xx { struct A {}; } xx::A a;", Matcher));
   EXPECT_TRUE(notMatches("struct ns { struct A {}; }; ns::A a;", Matcher));
 }
 
 TEST(NNS, BindsNestedNameSpecifiers) {
   EXPECT_TRUE(matchAndVerifyResultTrue(
       "namespace ns { struct E { struct B {}; }; } ns::E::B b;",
       nestedNameSpecifier(specifiesType(asString("struct ns::E"))).bind("nns"),
-      new VerifyIdIsBoundTo<NestedNameSpecifier>("nns", "ns::struct E::")));
+      llvm::make_unique<VerifyIdIsBoundTo<NestedNameSpecifier>>(
+          "nns", "ns::struct E::")));
 }
 
 TEST(NNS, BindsNestedNameSpecifierLocs) {
   EXPECT_TRUE(matchAndVerifyResultTrue(
       "namespace ns { struct B {}; } ns::B b;",
       loc(nestedNameSpecifier()).bind("loc"),
-      new VerifyIdIsBoundTo<NestedNameSpecifierLoc>("loc", 1)));
+      llvm::make_unique<VerifyIdIsBoundTo<NestedNameSpecifierLoc>>("loc", 1)));
 }
 
 TEST(NNS, MatchesNestedNameSpecifierPrefixes) {
   EXPECT_TRUE(matches(
       "struct A { struct B { struct C {}; }; }; A::B::C c;",
       nestedNameSpecifier(hasPrefix(specifiesType(asString("struct A"))))));
   EXPECT_TRUE(matches(
       "struct A { struct B { struct C {}; }; }; A::B::C c;",
EXPECT_TRUE(matches(
                               specifiesNamespace(hasName("a")))))));
 
   // Not really useful because a NestedNameSpecifier can af at most one child,
   // but to complete the interface.
   EXPECT_TRUE(matchAndVerifyResultTrue(
       Fragment,
       nestedNameSpecifier(specifiesType(asString("struct a::A::B")),
                           forEach(nestedNameSpecifier().bind("x"))),
-      new VerifyIdIsBoundTo<NestedNameSpecifier>("x", 1)));
+      llvm::make_unique<VerifyIdIsBoundTo<NestedNameSpecifier>>("x", 1)));
 }
 
 TEST(NNS, NestedNameSpecifiersAsDescendants) {
   std::string Fragment =
       "namespace a { struct A { struct B { struct C {}; }; }; };"
       "void f() { a::A::B::C c; }";
   EXPECT_TRUE(matches(
       Fragment,
       decl(hasDescendant(nestedNameSpecifier(specifiesType(
           asString("struct a::A")))))));
   EXPECT_TRUE(matchAndVerifyResultTrue(
       Fragment,
       functionDecl(hasName("f"),
                    forEachDescendant(nestedNameSpecifier().bind("x"))),
       // Nested names: a, a::A and a::A::B.
-      new VerifyIdIsBoundTo<NestedNameSpecifier>("x", 3)));
+      llvm::make_unique<VerifyIdIsBoundTo<NestedNameSpecifier>>("x", 3)));
 }
 
 TEST(NNSLoc, DescendantsOfNestedNameSpecifierLocs) {
   std::string Fragment =
       "namespace a { struct A { struct B { struct C {}; }; }; };"
       "void f() { a::A::B::C c; }";
   EXPECT_TRUE(matches(
       Fragment,
EXPECT_TRUE(matches(
       nestedNameSpecifierLoc(loc(specifiesType(asString("struct a::A"))),
                              has(loc(nestedNameSpecifier(
                                  specifiesNamespace(hasName("a"))))))));
 
   EXPECT_TRUE(matchAndVerifyResultTrue(
       Fragment,
       nestedNameSpecifierLoc(loc(specifiesType(asString("struct a::A::B"))),
                              forEach(nestedNameSpecifierLoc().bind("x"))),
-      new VerifyIdIsBoundTo<NestedNameSpecifierLoc>("x", 1)));
+      llvm::make_unique<VerifyIdIsBoundTo<NestedNameSpecifierLoc>>("x", 1)));
 }
 
 TEST(NNSLoc, NestedNameSpecifierLocsAsDescendants) {
   std::string Fragment =
       "namespace a { struct A { struct B { struct C {}; }; }; };"
       "void f() { a::A::B::C c; }";
   EXPECT_TRUE(matches(
       Fragment,
       decl(hasDescendant(loc(nestedNameSpecifier(specifiesType(
           asString("struct a::A"))))))));
   EXPECT_TRUE(matchAndVerifyResultTrue(
       Fragment,
       functionDecl(hasName("f"),
                    forEachDescendant(nestedNameSpecifierLoc().bind("x"))),
       // Nested names: a, a::A and a::A::B.
-      new VerifyIdIsBoundTo<NestedNameSpecifierLoc>("x", 3)));
+      llvm::make_unique<VerifyIdIsBoundTo<NestedNameSpecifierLoc>>("x", 3)));
 }
 
 template <typename T> class VerifyMatchOnNode : public BoundNodesCallback {
 public:
   VerifyMatchOnNode(StringRef Id, const internal::Matcher<T> &InnerMatcher,
                     StringRef InnerId)
       : Id(Id), InnerMatcher(InnerMatcher), InnerId(InnerId) {
   }
private:
   std::string Id;
   internal::Matcher<T> InnerMatcher;
   std::string InnerId;
 };
 
 TEST(MatchFinder, CanMatchDeclarationsRecursively) {
   EXPECT_TRUE(matchAndVerifyResultTrue(
       "class X { class Y {}; };", recordDecl(hasName("::X")).bind("X"),
-      new VerifyMatchOnNode<clang::Decl>(
+      llvm::make_unique<VerifyMatchOnNode<Decl>>(
           "X", decl(hasDescendant(recordDecl(hasName("X::Y")).bind("Y"))),
           "Y")));
   EXPECT_TRUE(matchAndVerifyResultFalse(
       "class X { class Y {}; };", recordDecl(hasName("::X")).bind("X"),
-      new VerifyMatchOnNode<clang::Decl>(
+      llvm::make_unique<VerifyMatchOnNode<Decl>>(
           "X", decl(hasDescendant(recordDecl(hasName("X::Z")).bind("Z"))),
           "Z")));
 }
 
 TEST(MatchFinder, CanMatchStatementsRecursively) {
   EXPECT_TRUE(matchAndVerifyResultTrue(
       "void f() { if (1) { for (;;) { } } }", ifStmt().bind("if"),
-      new VerifyMatchOnNode<clang::Stmt>(
+      llvm::make_unique<VerifyMatchOnNode<Stmt>>(
           "if", stmt(hasDescendant(forStmt().bind("for"))), "for")));
   EXPECT_TRUE(matchAndVerifyResultFalse(
       "void f() { if (1) { for (;;) { } } }", ifStmt().bind("if"),
-      new VerifyMatchOnNode<clang::Stmt>(
+      llvm::make_unique<VerifyMatchOnNode<Stmt>>(
           "if", stmt(hasDescendant(declStmt().bind("decl"))), "decl")));
 }
 
 TEST(MatchFinder, CanMatchSingleNodesRecursively) {
   EXPECT_TRUE(matchAndVerifyResultTrue(
       "class X { class Y {}; };", recordDecl(hasName("::X")).bind("X"),
-      new VerifyMatchOnNode<clang::Decl>(
+      llvm::make_unique<VerifyMatchOnNode<Decl>>(
           "X", recordDecl(has(recordDecl(hasName("X::Y")).bind("Y"))), "Y")));
   EXPECT_TRUE(matchAndVerifyResultFalse(
       "class X { class Y {}; };", recordDecl(hasName("::X")).bind("X"),
-      new VerifyMatchOnNode<clang::Decl>(
+      llvm::make_unique<VerifyMatchOnNode<Decl>>(
           "X", recordDecl(has(recordDecl(hasName("X::Z")).bind("Z"))), "Z")));
 }
 
 template <typename T>
 class VerifyAncestorHasChildIsEqual : public BoundNodesCallback {
 public:
   bool run(const BoundNodes *Nodes) override { return false; }
 
return selectFirst<T>(
                              hasType(type(equalsNode(TypedNode)).bind(""))))))),
                          *Dec, Context)) != nullptr;
   }
 };
 
 TEST(IsEqualTo, MatchesNodesByIdentity) {
   EXPECT_TRUE(matchAndVerifyResultTrue(
       "class X { class Y {}; };", recordDecl(hasName("::X::Y")).bind(""),
-      new VerifyAncestorHasChildIsEqual<CXXRecordDecl>()));
+      llvm::make_unique<VerifyAncestorHasChildIsEqual<CXXRecordDecl>>()));
   EXPECT_TRUE(matchAndVerifyResultTrue(
       "void f() { if (true) if(true) {} }", ifStmt().bind(""),
-      new VerifyAncestorHasChildIsEqual<IfStmt>()));
+      llvm::make_unique<VerifyAncestorHasChildIsEqual<IfStmt>>()));
   EXPECT_TRUE(matchAndVerifyResultTrue(
       "class X { class Y {} y; };",
       fieldDecl(hasName("y"), hasType(type().bind(""))).bind("decl"),
-      new VerifyAncestorHasChildIsEqual<Type>()));
+      llvm::make_unique<VerifyAncestorHasChildIsEqual<Type>>()));
 }
 
 TEST(MatchFinder, CheckProfiling) {
   MatchFinder::MatchFinderOptions Options;
   llvm::StringMap<llvm::TimeRecord> Records;
   Options.CheckProfiling.emplace(Records);
   MatchFinder Finder(std::move(Options));
 
EXPECT_TRUE(matchAndVerifyResultTrue(
       "  return 0;"
       "}",
       // Look for variable declarations within functions whose type is the same
       // as the function return type.
       functionDecl(returns(qualType().bind("type")),
                    forEachDescendant(varDecl(hasType(
                        qualType(equalsBoundNode("type")))).bind("decl"))),
       // Only i and j should match, not k.
-      new VerifyIdIsBoundTo<VarDecl>("decl", 2)));
+      llvm::make_unique<VerifyIdIsBoundTo<VarDecl>>("decl", 2)));
 }
 
 TEST(EqualsBoundNodeMatcher, FiltersMatchedCombinations) {
   EXPECT_TRUE(matchAndVerifyResultTrue(
       "void f() {"
       "  int x;"
       "  double d;"
       "  x = d + x - d + x;"
       "}",
       functionDecl(
           hasName("f"), forEachDescendant(varDecl().bind("d")),
           forEachDescendant(declRefExpr(to(decl(equalsBoundNode("d")))))),
-      new VerifyIdIsBoundTo<VarDecl>("d", 5)));
+      llvm::make_unique<VerifyIdIsBoundTo<VarDecl>>("d", 5)));
 }
 
 TEST(EqualsBoundNodeMatcher, UnlessDescendantsOfAncestorsMatch) {
   EXPECT_TRUE(matchAndVerifyResultTrue(
       "struct StringRef { int size() const; const char* data() const; };"
       "void f(StringRef v) {"
       "  v.data();"
       "}",
       cxxMemberCallExpr(
           callee(cxxMethodDecl(hasName("data"))),
           on(declRefExpr(to(
               varDecl(hasType(recordDecl(hasName("StringRef")))).bind("var")))),
           unless(hasAncestor(stmt(hasDescendant(cxxMemberCallExpr(
               callee(cxxMethodDecl(anyOf(hasName("size"), hasName("length")))),
               on(declRefExpr(to(varDecl(equalsBoundNode("var")))))))))))
           .bind("data"),
-      new VerifyIdIsBoundTo<Expr>("data", 1)));
+      llvm::make_unique<VerifyIdIsBoundTo<Expr>>("data", 1)));
 
   EXPECT_FALSE(matches(
       "struct StringRef { int size() const; const char* data() const; };"
       "void f(StringRef v) {"
       "  v.data();"
       "  v.size();"
       "}",
       cxxMemberCallExpr(