--- a/clang/unittests/Tooling/FixItTest.cpp	Wed Jul 21 10:27:27 2021 +0900
+++ b/clang/unittests/Tooling/FixItTest.cpp	Wed Nov 09 17:45:10 2022 +0900
@@ -6,9 +6,11 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "TestVisitor.h"
-#include "clang/Basic/Diagnostic.h"
 #include "clang/Tooling/FixIt.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/ASTMatchers/ASTMatchers.h"
+#include "clang/Testing/TestAST.h"
+#include "gtest/gtest.h"
 
 using namespace clang;
 
@@ -18,214 +20,169 @@
 
 namespace {
 
-struct CallsVisitor : TestVisitor<CallsVisitor> {
-  bool VisitCallExpr(CallExpr *Expr) {
-    OnCall(Expr, Context);
-    return true;
-  }
-
-  std::function<void(CallExpr *, ASTContext *Context)> OnCall;
-};
-
-std::string LocationToString(SourceLocation Loc, ASTContext *Context) {
-  return Loc.printToString(Context->getSourceManager());
+const CallExpr &onlyCall(ASTContext &Ctx) {
+  using namespace ast_matchers;
+  auto Calls = match(callExpr().bind(""), Ctx);
+  EXPECT_EQ(Calls.size(), 1u);
+  return *Calls.front().getNodeAs<CallExpr>("");
 }
 
 TEST(FixItTest, getText) {
-  CallsVisitor Visitor;
-
-  Visitor.OnCall = [](CallExpr *CE, ASTContext *Context) {
-    EXPECT_EQ("foo(x, y)", getText(*CE, *Context));
-    EXPECT_EQ("foo(x, y)", getText(CE->getSourceRange(), *Context));
+  TestAST AST("void foo(int x, int y) { foo(x, y); }");
+  const CallExpr &CE = onlyCall(AST.context());
+  EXPECT_EQ("foo(x, y)", getText(CE, AST.context()));
+  EXPECT_EQ("foo(x, y)", getText(CE.getSourceRange(), AST.context()));
+  EXPECT_EQ("x", getText(*CE.getArg(0), AST.context()));
+  EXPECT_EQ("y", getText(*CE.getArg(1), AST.context()));
 
-    Expr *P0 = CE->getArg(0);
-    Expr *P1 = CE->getArg(1);
-    EXPECT_EQ("x", getText(*P0, *Context));
-    EXPECT_EQ("y", getText(*P1, *Context));
-  };
-  Visitor.runOver("void foo(int x, int y) { foo(x, y); }");
-
-  Visitor.OnCall = [](CallExpr *CE, ASTContext *Context) {
-    EXPECT_EQ("APPLY(foo, x, y)", getText(*CE, *Context));
-  };
-  Visitor.runOver("#define APPLY(f, x, y) f(x, y)\n"
-                  "void foo(int x, int y) { APPLY(foo, x, y); }");
+  AST = TestAST("#define APPLY(f, x, y) f(x, y)\n"
+                "void foo(int x, int y) { APPLY(foo, x, y); }");
+  const CallExpr &CE2 = onlyCall(AST.context());
+  EXPECT_EQ("APPLY(foo, x, y)", getText(CE2, AST.context()));
 }
 
 TEST(FixItTest, getTextWithMacro) {
-  CallsVisitor Visitor;
+  TestAST AST("#define F foo(\n"
+              "#define OO x, y)\n"
+              "void foo(int x, int y) { F OO ; }");
+  const CallExpr &CE = onlyCall(AST.context());
+  EXPECT_EQ("F OO", getText(CE, AST.context()));
+  EXPECT_EQ("", getText(*CE.getArg(0), AST.context()));
+  EXPECT_EQ("", getText(*CE.getArg(1), AST.context()));
 
-  Visitor.OnCall = [](CallExpr *CE, ASTContext *Context) {
-    EXPECT_EQ("F OO", getText(*CE, *Context));
-    Expr *P0 = CE->getArg(0);
-    Expr *P1 = CE->getArg(1);
-    EXPECT_EQ("", getText(*P0, *Context));
-    EXPECT_EQ("", getText(*P1, *Context));
-  };
-  Visitor.runOver("#define F foo(\n"
-                  "#define OO x, y)\n"
-                  "void foo(int x, int y) { F OO ; }");
-
-  Visitor.OnCall = [](CallExpr *CE, ASTContext *Context) {
-    EXPECT_EQ("", getText(*CE, *Context));
-    Expr *P0 = CE->getArg(0);
-    Expr *P1 = CE->getArg(1);
-    EXPECT_EQ("x", getText(*P0, *Context));
-    EXPECT_EQ("y", getText(*P1, *Context));
-  };
-  Visitor.runOver("#define FOO(x, y) (void)x; (void)y; foo(x, y);\n"
-                  "void foo(int x, int y) { FOO(x,y) }");
+  AST = TestAST("#define FOO(x, y) (void)x; (void)y; foo(x, y);\n"
+                "void foo(int x, int y) { FOO(x,y) }");
+  const CallExpr &CE2 = onlyCall(AST.context());
+  EXPECT_EQ("", getText(CE2, AST.context()));
+  EXPECT_EQ("x", getText(*CE2.getArg(0), AST.context()));
+  EXPECT_EQ("y", getText(*CE2.getArg(1), AST.context()));
 }
 
 TEST(FixItTest, createRemoval) {
-  CallsVisitor Visitor;
+  TestAST AST("void foo(int x, int y) { foo(x, y); }");
+  const CallExpr &CE = onlyCall(AST.context());
 
-  Visitor.OnCall = [](CallExpr *CE, ASTContext *Context) {
-    FixItHint Hint = createRemoval(*CE);
-    EXPECT_EQ("foo(x, y)", getText(Hint.RemoveRange.getAsRange(), *Context));
-    EXPECT_TRUE(Hint.InsertFromRange.isInvalid());
-    EXPECT_TRUE(Hint.CodeToInsert.empty());
+  FixItHint Hint = createRemoval(CE);
+  EXPECT_EQ("foo(x, y)", getText(Hint.RemoveRange.getAsRange(), AST.context()));
+  EXPECT_TRUE(Hint.InsertFromRange.isInvalid());
+  EXPECT_TRUE(Hint.CodeToInsert.empty());
 
-    Expr *P0 = CE->getArg(0);
-    FixItHint Hint0 = createRemoval(*P0);
-    EXPECT_EQ("x", getText(Hint0.RemoveRange.getAsRange(), *Context));
-    EXPECT_TRUE(Hint0.InsertFromRange.isInvalid());
-    EXPECT_TRUE(Hint0.CodeToInsert.empty());
+  FixItHint Hint0 = createRemoval(*CE.getArg(0));
+  EXPECT_EQ("x", getText(Hint0.RemoveRange.getAsRange(), AST.context()));
+  EXPECT_TRUE(Hint0.InsertFromRange.isInvalid());
+  EXPECT_TRUE(Hint0.CodeToInsert.empty());
 
-    Expr *P1 = CE->getArg(1);
-    FixItHint Hint1 = createRemoval(*P1);
-    EXPECT_EQ("y", getText(Hint1.RemoveRange.getAsRange(), *Context));
-    EXPECT_TRUE(Hint1.InsertFromRange.isInvalid());
-    EXPECT_TRUE(Hint1.CodeToInsert.empty());
-  };
-  Visitor.runOver("void foo(int x, int y) { foo(x, y); }");
+  FixItHint Hint1 = createRemoval(*CE.getArg(1));
+  EXPECT_EQ("y", getText(Hint1.RemoveRange.getAsRange(), AST.context()));
+  EXPECT_TRUE(Hint1.InsertFromRange.isInvalid());
+  EXPECT_TRUE(Hint1.CodeToInsert.empty());
 
-  Visitor.OnCall = [](CallExpr *CE, ASTContext *Context) {
-    Expr *P0 = CE->getArg(0);
-    FixItHint Hint0 = createRemoval(*P0);
-    EXPECT_EQ("x + y", getText(Hint0.RemoveRange.getAsRange(), *Context));
+  AST = TestAST("void foo(int x, int y) { foo(x + y, y + x); }");
+  const CallExpr &CE2 = onlyCall(AST.context());
+  Hint0 = createRemoval(*CE2.getArg(0));
+  EXPECT_EQ("x + y", getText(Hint0.RemoveRange.getAsRange(), AST.context()));
 
-    Expr *P1 = CE->getArg(1);
-    FixItHint Hint1 = createRemoval(*P1);
-    EXPECT_EQ("y + x", getText(Hint1.RemoveRange.getAsRange(), *Context));
-  };
-  Visitor.runOver("void foo(int x, int y) { foo(x + y, y + x); }");
+  Hint1 = createRemoval(*CE2.getArg(1));
+  EXPECT_EQ("y + x", getText(Hint1.RemoveRange.getAsRange(), AST.context()));
 }
 
 TEST(FixItTest, createRemovalWithMacro) {
-  CallsVisitor Visitor;
-
-  Visitor.OnCall = [](CallExpr *CE, ASTContext *Context) {
-    FixItHint Hint = createRemoval(*CE);
-    EXPECT_EQ("FOO", getText(Hint.RemoveRange.getAsRange(), *Context));
-    EXPECT_TRUE(Hint.InsertFromRange.isInvalid());
-    EXPECT_TRUE(Hint.CodeToInsert.empty());
+  TestAST AST("#define FOO foo(1, 1)\n"
+              "void foo(int x, int y) { FOO; }");
+  const CallExpr &CE = onlyCall(AST.context());
+  FixItHint Hint = createRemoval(CE);
+  EXPECT_EQ("FOO", getText(Hint.RemoveRange.getAsRange(), AST.context()));
+  EXPECT_TRUE(Hint.InsertFromRange.isInvalid());
+  EXPECT_TRUE(Hint.CodeToInsert.empty());
 
-    Expr *P0 = CE->getArg(0);
-    FixItHint Hint0 = createRemoval(*P0);
-    EXPECT_EQ("input.cc:2:26 <Spelling=input.cc:1:17>",
-              LocationToString(Hint0.RemoveRange.getBegin(), Context));
-    EXPECT_EQ("input.cc:2:26 <Spelling=input.cc:1:17>",
-              LocationToString(Hint0.RemoveRange.getEnd(), Context));
-    EXPECT_TRUE(Hint0.InsertFromRange.isInvalid());
-    EXPECT_TRUE(Hint0.CodeToInsert.empty());
+  FixItHint Hint0 = createRemoval(*CE.getArg(0));
+  EXPECT_EQ("input.mm:2:26 <Spelling=input.mm:1:17>",
+            Hint0.RemoveRange.getBegin().printToString(AST.sourceManager()));
+  EXPECT_EQ("input.mm:2:26 <Spelling=input.mm:1:17>",
+            Hint0.RemoveRange.getEnd().printToString(AST.sourceManager()));
+  EXPECT_TRUE(Hint0.InsertFromRange.isInvalid());
+  EXPECT_TRUE(Hint0.CodeToInsert.empty());
 
-    Expr *P1 = CE->getArg(1);
-    FixItHint Hint1 = createRemoval(*P1);
-    EXPECT_EQ("input.cc:2:26 <Spelling=input.cc:1:20>",
-              LocationToString(Hint1.RemoveRange.getBegin(), Context));
-    EXPECT_EQ("input.cc:2:26 <Spelling=input.cc:1:20>",
-              LocationToString(Hint1.RemoveRange.getEnd(), Context));
-    EXPECT_TRUE(Hint1.InsertFromRange.isInvalid());
-    EXPECT_TRUE(Hint1.CodeToInsert.empty());
-  };
-  Visitor.runOver("#define FOO foo(1, 1)\n"
-                  "void foo(int x, int y) { FOO; }");
+  FixItHint Hint1 = createRemoval(*CE.getArg(1));
+  EXPECT_EQ("input.mm:2:26 <Spelling=input.mm:1:20>",
+            Hint1.RemoveRange.getBegin().printToString(AST.sourceManager()));
+  EXPECT_EQ("input.mm:2:26 <Spelling=input.mm:1:20>",
+            Hint1.RemoveRange.getEnd().printToString(AST.sourceManager()));
+  EXPECT_TRUE(Hint1.InsertFromRange.isInvalid());
+  EXPECT_TRUE(Hint1.CodeToInsert.empty());
 
-  Visitor.OnCall = [](CallExpr *CE, ASTContext *Context) {
-    FixItHint Hint = createRemoval(*CE);
-    EXPECT_EQ("input.cc:2:26 <Spelling=input.cc:1:37>",
-              LocationToString(Hint.RemoveRange.getBegin(), Context));
-    EXPECT_EQ("input.cc:2:26 <Spelling=input.cc:1:45>",
-              LocationToString(Hint.RemoveRange.getEnd(), Context));
-    EXPECT_TRUE(Hint.InsertFromRange.isInvalid());
-    EXPECT_TRUE(Hint.CodeToInsert.empty());
-  };
-  Visitor.runOver("#define FOO(x, y) (void)x; (void)y; foo(x, y);\n"
-                  "void foo(int x, int y) { FOO(x,y) }");
+  AST = TestAST("#define FOO(x, y) (void)x; (void)y; foo(x, y);\n"
+                "void foo(int x, int y) { FOO(x,y) }");
+  const CallExpr &CE2 = onlyCall(AST.context());
+  Hint = createRemoval(CE2);
+  EXPECT_EQ("input.mm:2:26 <Spelling=input.mm:1:37>",
+            Hint.RemoveRange.getBegin().printToString(AST.sourceManager()));
+  EXPECT_EQ("input.mm:2:26 <Spelling=input.mm:1:45>",
+            Hint.RemoveRange.getEnd().printToString(AST.sourceManager()));
+  EXPECT_TRUE(Hint.InsertFromRange.isInvalid());
+  EXPECT_TRUE(Hint.CodeToInsert.empty());
 }
 
 TEST(FixItTest, createReplacement) {
-  CallsVisitor Visitor;
+  for (const char *Code : {
+           "void foo(int x, int y) { foo(x, y); }",
+
+           "#define APPLY(f, x, y) f(x, y)\n"
+           "void foo(int x, int y) { APPLY(foo, x, y); }",
 
-  Visitor.OnCall = [](CallExpr *CE, ASTContext *Context) {
-    Expr *P0 = CE->getArg(0);
-    Expr *P1 = CE->getArg(1);
-    FixItHint Hint0 = createReplacement(*P0, *P1, *Context);
-    FixItHint Hint1 = createReplacement(*P1, *P0, *Context);
+           "#define APPLY(f, P) f(P)\n"
+           "#define PAIR(x, y) x, y\n"
+           "void foo(int x, int y) { APPLY(foo, PAIR(x, y)); }\n",
+       }) {
+    TestAST AST(Code);
+    const CallExpr &CE = onlyCall(AST.context());
+    const Expr *P0 = CE.getArg(0);
+    const Expr *P1 = CE.getArg(1);
+    FixItHint Hint0 = createReplacement(*P0, *P1, AST.context());
+    FixItHint Hint1 = createReplacement(*P1, *P0, AST.context());
 
     // Validate Hint0 fields.
-    EXPECT_EQ("x", getText(Hint0.RemoveRange.getAsRange(), *Context));
+    EXPECT_EQ("x", getText(Hint0.RemoveRange.getAsRange(), AST.context()));
     EXPECT_TRUE(Hint0.InsertFromRange.isInvalid());
     EXPECT_EQ(Hint0.CodeToInsert, "y");
 
     // Validate Hint1 fields.
-    EXPECT_EQ("y", getText(Hint1.RemoveRange.getAsRange(), *Context));
+    EXPECT_EQ("y", getText(Hint1.RemoveRange.getAsRange(), AST.context()));
     EXPECT_TRUE(Hint1.InsertFromRange.isInvalid());
     EXPECT_EQ(Hint1.CodeToInsert, "x");
-  };
-
-  Visitor.runOver("void foo(int x, int y) { foo(x, y); }");
-
-  Visitor.runOver("#define APPLY(f, x, y) f(x, y)\n"
-                  "void foo(int x, int y) { APPLY(foo, x, y); }");
-
-  Visitor.runOver("#define APPLY(f, P) f(P)\n"
-                  "#define PAIR(x, y) x, y\n"
-                  "void foo(int x, int y) { APPLY(foo, PAIR(x, y)); }\n");
+  }
 }
 
 TEST(FixItTest, createReplacementWithMacro) {
-  CallsVisitor Visitor;
-
-  Visitor.OnCall = [](CallExpr *CE, ASTContext *Context) {
-    Expr *P0 = CE->getArg(0);
-    Expr *P1 = CE->getArg(1);
-    FixItHint Hint = createReplacement(*P0, *P1, *Context);
-    EXPECT_EQ("input.cc:2:26 <Spelling=input.cc:1:17>",
-              LocationToString(Hint.RemoveRange.getBegin(), Context));
-    EXPECT_EQ("input.cc:2:26 <Spelling=input.cc:1:17>",
-              LocationToString(Hint.RemoveRange.getEnd(), Context));
-    EXPECT_TRUE(Hint.InsertFromRange.isInvalid());
-    EXPECT_TRUE(Hint.CodeToInsert.empty());
-  };
-
-  Visitor.runOver("#define FOO foo(1, 1)\n"
-                  "void foo(int x, int y) { FOO; }");
+  TestAST AST("#define FOO foo(1, 1)\n"
+              "void foo(int x, int y) { FOO; }");
+  const CallExpr &CE = onlyCall(AST.context());
+  FixItHint Hint =
+      createReplacement(*CE.getArg(0), *CE.getArg(1), AST.context());
+  EXPECT_EQ("input.mm:2:26 <Spelling=input.mm:1:17>",
+            Hint.RemoveRange.getBegin().printToString(AST.sourceManager()));
+  EXPECT_EQ("input.mm:2:26 <Spelling=input.mm:1:17>",
+            Hint.RemoveRange.getEnd().printToString(AST.sourceManager()));
+  EXPECT_TRUE(Hint.InsertFromRange.isInvalid());
+  EXPECT_TRUE(Hint.CodeToInsert.empty());
 
-  Visitor.OnCall = [](CallExpr *CE, ASTContext *Context) {
-    Expr *P0 = CE->getArg(0);
-    Expr *P1 = CE->getArg(1);
-    FixItHint Hint = createReplacement(*P0, *P1, *Context);
-    EXPECT_EQ("input.cc:2:26 <Spelling=input.cc:2:30>",
-              LocationToString(Hint.RemoveRange.getBegin(), Context));
-    EXPECT_EQ("input.cc:2:26 <Spelling=input.cc:2:30>",
-              LocationToString(Hint.RemoveRange.getEnd(), Context));
-    EXPECT_TRUE(Hint.InsertFromRange.isInvalid());
-    EXPECT_EQ("y", Hint.CodeToInsert);
-  };
-  Visitor.runOver("#define FOO(x, y) (void)x; (void)y; foo(x, y);\n"
-                  "void foo(int x, int y) { FOO(x,y) }");
+  AST = TestAST("#define FOO(x, y) (void)x; (void)y; foo(x, y);\n"
+                "void foo(int x, int y) { FOO(x,y) }");
+  const CallExpr &CE2 = onlyCall(AST.context());
+  Hint = createReplacement(*CE2.getArg(0), *CE2.getArg(1), AST.context());
+  EXPECT_EQ("input.mm:2:26 <Spelling=input.mm:2:30>",
+            Hint.RemoveRange.getEnd().printToString(AST.sourceManager()));
+  EXPECT_EQ("input.mm:2:26 <Spelling=input.mm:2:30>",
+            Hint.RemoveRange.getBegin().printToString(AST.sourceManager()));
+  EXPECT_TRUE(Hint.InsertFromRange.isInvalid());
+  EXPECT_EQ("y", Hint.CodeToInsert);
 
-  Visitor.OnCall = [](CallExpr *CE, ASTContext *Context) {
-    Expr *P0 = CE->getArg(0);
-    Expr *P1 = CE->getArg(1);
-    FixItHint Hint = createReplacement(*P0, *P1, *Context);
-    EXPECT_EQ("x + y", getText(Hint.RemoveRange.getAsRange(), *Context));
-    EXPECT_TRUE(Hint.InsertFromRange.isInvalid());
-    EXPECT_EQ("y + x", Hint.CodeToInsert);
-  };
-  Visitor.runOver("void foo(int x, int y) { foo(x + y, y + x); }");
+  AST = TestAST("void foo(int x, int y) { foo(x + y, y + x); }");
+  const CallExpr &CE3 = onlyCall(AST.context());
+  Hint = createReplacement(*CE3.getArg(0), *CE3.getArg(1), AST.context());
+  EXPECT_EQ("x + y", getText(Hint.RemoveRange.getAsRange(), AST.context()));
+  EXPECT_TRUE(Hint.InsertFromRange.isInvalid());
+  EXPECT_EQ("y + x", Hint.CodeToInsert);
 }
 
 } // end anonymous namespace