[clang] d65952b - [clang] Adjust LookupTest for UsingTypeLocs

[Kadir Cetinkaya via cfe-commits]

Author: Kadir Cetinkaya
Date: 2022-03-07T16:22:03+01:00
New Revision: d65952b9bd8099b7405a4168d501596256a49f87

URL: https://github.com/llvm/llvm-project/commit/d65952b9bd8099b7405a4168d501596256a49f87
DIFF: https://github.com/llvm/llvm-project/commit/d65952b9bd8099b7405a4168d501596256a49f87.diff

LOG: [clang] Adjust LookupTest for UsingTypeLocs

We no longer traverse the underlying RecordTypeLoc directly, but rather
visit the UsingTypeLoc.

Differential Revision: https://reviews.llvm.org/D121103

Added: 
    

Modified: 
    clang/unittests/Tooling/LookupTest.cpp

Removed: 
    


################################################################################
diff  --git a/clang/unittests/Tooling/LookupTest.cpp b/clang/unittests/Tooling/LookupTest.cpp
index 05494cb42d904..2cf5ebb2a4cbd 100644
--- a/clang/unittests/Tooling/LookupTest.cpp
+++ b/clang/unittests/Tooling/LookupTest.cpp
@@ -8,12 +8,15 @@
 
 #include "clang/Tooling/Refactoring/Lookup.h"
 #include "TestVisitor.h"
+#include "clang/AST/TypeLoc.h"
+#include "clang/Basic/SourceLocation.h"
 using namespace clang;
 
 namespace {
 struct GetDeclsVisitor : TestVisitor<GetDeclsVisitor> {
   std::function<void(CallExpr *)> OnCall;
   std::function<void(RecordTypeLoc)> OnRecordTypeLoc;
+  std::function<void(UsingTypeLoc)> OnUsingTypeLoc;
   SmallVector<Decl *, 4> DeclStack;
 
   bool VisitCallExpr(CallExpr *Expr) {
@@ -28,6 +31,12 @@ struct GetDeclsVisitor : TestVisitor<GetDeclsVisitor> {
     return true;
   }
 
+  bool VisitUsingTypeLoc(UsingTypeLoc Loc) {
+    if (OnUsingTypeLoc)
+      OnUsingTypeLoc(Loc);
+    return true;
+  }
+
   bool TraverseDecl(Decl *D) {
     DeclStack.push_back(D);
     bool Ret = TestVisitor::TraverseDecl(D);
@@ -181,19 +190,19 @@ TEST(LookupTest, replaceNestedFunctionName) {
 TEST(LookupTest, replaceNestedClassName) {
   GetDeclsVisitor Visitor;
 
-  auto replaceRecordTypeLoc = [&](RecordTypeLoc TLoc,
-                                  StringRef ReplacementString) {
-    const auto *FD = cast<CXXRecordDecl>(TLoc.getDecl());
+  auto replaceTypeLoc = [&](const NamedDecl *ND, SourceLocation Loc,
+                            StringRef ReplacementString) {
     return tooling::replaceNestedName(
-        nullptr, TLoc.getBeginLoc(), Visitor.DeclStack.back()->getDeclContext(),
-        FD, ReplacementString);
+        nullptr, Loc, Visitor.DeclStack.back()->getDeclContext(), ND,
+        ReplacementString);
   };
 
   Visitor.OnRecordTypeLoc = [&](RecordTypeLoc Type) {
     // Filter Types by name since there are other `RecordTypeLoc` in the test
     // file.
     if (Type.getDecl()->getQualifiedNameAsString() == "a::b::Foo") {
-      EXPECT_EQ("x::Bar", replaceRecordTypeLoc(Type, "::a::x::Bar"));
+      EXPECT_EQ("x::Bar", replaceTypeLoc(Type.getDecl(), Type.getBeginLoc(),
+                                         "::a::x::Bar"));
     }
   };
   Visitor.runOver("namespace a { namespace b {\n"
@@ -201,12 +210,13 @@ TEST(LookupTest, replaceNestedClassName) {
                   "namespace c { Foo f();; }\n"
                   "} }\n");
 
-  Visitor.OnRecordTypeLoc = [&](RecordTypeLoc Type) {
+  Visitor.OnUsingTypeLoc = [&](UsingTypeLoc Type) {
     // Filter Types by name since there are other `RecordTypeLoc` in the test
     // file.
     // `a::b::Foo` in using shadow decl is not `TypeLoc`.
-    if (Type.getDecl()->getQualifiedNameAsString() == "a::b::Foo") {
-      EXPECT_EQ("Bar", replaceRecordTypeLoc(Type, "::a::x::Bar"));
+    auto *TD = Type.getFoundDecl()->getTargetDecl();
+    if (TD->getQualifiedNameAsString() == "a::b::Foo") {
+      EXPECT_EQ("Bar", replaceTypeLoc(TD, Type.getBeginLoc(), "::a::x::Bar"));
     }
   };
   Visitor.runOver("namespace a { namespace b { class Foo {}; } }\n"
@@ -218,7 +228,8 @@ TEST(LookupTest, replaceNestedClassName) {
   // it's not visible at [0].
   Visitor.OnRecordTypeLoc = [&](RecordTypeLoc Type) {
     if (Type.getDecl()->getQualifiedNameAsString() == "x::y::Old") {
-      EXPECT_EQ("Foo", replaceRecordTypeLoc(Type, "::x::Foo"));
+      EXPECT_EQ("Foo",
+                replaceTypeLoc(Type.getDecl(), Type.getBeginLoc(), "::x::Foo"));
     }
   };
   Visitor.runOver(R"(