[libclang] CIndex: Visit UsingTypeLoc as TypeRef

[sammccall]

clang/unittests/libclang/TestUtils.h

85

nit: if you're moving this function here, I think you should also rename it to either fromCXString (matches style guide) or FromCXString (matches surrounding code)

[kiloalphaindia]

renamed function from_CXString -> fromCXString

[kiloalphaindia]

@sammccall I don't think I can commit anything. Can you please do it?

clang/tools/libclang/CIndex.cpp

 bool CursorVisitor::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) {
   return Visit(TL.getPointeeLoc());
 }
 
 bool CursorVisitor::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) {
   return Visit(TL.getPointeeLoc());
 }
 
-bool CursorVisitor::VisitUsingTypeLoc(UsingTypeLoc TL) { return false; }
+bool CursorVisitor::VisitUsingTypeLoc(UsingTypeLoc TL) {
+  auto *underlyingDecl = TL.getUnderlyingType()->getAsTagDecl();
+  if (underlyingDecl) {
+    return Visit(MakeCursorTypeRef(underlyingDecl, TL.getNameLoc(), TU));
+  }
+  return false;
+}
 
 bool CursorVisitor::VisitAttributedTypeLoc(AttributedTypeLoc TL) {
   return Visit(TL.getModifiedLoc());
 }
 
 bool CursorVisitor::VisitBTFTagAttributedTypeLoc(BTFTagAttributedTypeLoc TL) {
   return Visit(TL.getWrappedLoc());
 }

clang/unittests/libclang/LibclangTest.cpp

WriteFile(Header, "void foo1(const int);\n"
                     "void foo10(int* const volatile restrict);\n");
 
   auto is_qualified = [](CXType type) -> bool {
     return clang_isConstQualifiedType(type) ||
            clang_isVolatileQualifiedType(type) ||
            clang_isRestrictQualifiedType(type);
   };
 
-  auto from_CXString = [](CXString cx_string) -> std::string {
-    std::string string{clang_getCString(cx_string)};
-
-    clang_disposeString(cx_string);
-
-    return string;
-  };
-
   ClangTU = clang_parseTranslationUnit(Index, Header.c_str(), nullptr, 0,
                                        nullptr, 0, TUFlags);
 
-  Traverse([&is_qualified, &from_CXString](CXCursor cursor, CXCursor) {
+  Traverse([&is_qualified](CXCursor cursor, CXCursor) {
     if (clang_getCursorKind(cursor) == CXCursor_FunctionDecl) {
       CXType arg_type = clang_getArgType(clang_getCursorType(cursor), 0);
       EXPECT_TRUE(is_qualified(arg_type))
           << "Input data '" << from_CXString(clang_getCursorSpelling(cursor))
           << "' first argument does not have a qualified type.";
 
       CXType unqualified_arg_type = clang_getUnqualifiedType(arg_type);
       EXPECT_FALSE(is_qualified(unqualified_arg_type))
TEST_F(LibclangParseTest, clang_getNonReferenceTypeRemovesRefQualifiers) {
   WriteFile(Header, "void foo1(int&);\n"
                     "void foo2(int&&);\n");
 
   auto is_ref_qualified = [](CXType type) -> bool {
     return (type.kind == CXType_LValueReference) ||
            (type.kind == CXType_RValueReference);
   };
 
-  auto from_CXString = [](CXString cx_string) -> std::string {
-    std::string string{clang_getCString(cx_string)};
-
-    clang_disposeString(cx_string);
-
-    return string;
-  };
-
   const char *Args[] = {"-xc++"};
   ClangTU = clang_parseTranslationUnit(Index, Header.c_str(), Args, 1, nullptr,
                                        0, TUFlags);
 
-  Traverse([&is_ref_qualified, &from_CXString](CXCursor cursor, CXCursor) {
+  Traverse([&is_ref_qualified](CXCursor cursor, CXCursor) {
     if (clang_getCursorKind(cursor) == CXCursor_FunctionDecl) {
       CXType arg_type = clang_getArgType(clang_getCursorType(cursor), 0);
       EXPECT_TRUE(is_ref_qualified(arg_type))
           << "Input data '" << from_CXString(clang_getCursorSpelling(cursor))
           << "' first argument does not have a ref-qualified type.";
 
       CXType non_reference_arg_type = clang_getNonReferenceType(arg_type);
       EXPECT_FALSE(is_ref_qualified(non_reference_arg_type))
           << "The type '" << from_CXString(clang_getTypeSpelling(arg_type))
           << "' ref-qualifier was not removed after a call to "
              "clang_getNonReferenceType.";
     }
 
     return CXChildVisit_Continue;
   });
 }
 
+TEST_F(LibclangParseTest, VisitUsingTypeLoc) {
+  const char testSource[] = R"cpp(
+namespace ns1 {
+class Class1
+{
+    void fun();
+};
+}
+
+using ns1::Class1;
+
+void Class1::fun() {}
+)cpp";
+  std::string fileName = "main.cpp";
+  WriteFile(fileName, testSource);
+  const char *Args[] = {"-xc++"};
+  ClangTU = clang_parseTranslationUnit(Index, fileName.c_str(), Args, 1,
+                                       nullptr, 0, TUFlags);
+
+  llvm::Optional<CXCursor> typeRefCsr;
+  Traverse([&](CXCursor cursor, CXCursor parent) -> CXChildVisitResult {
+    if (cursor.kind == CXCursor_TypeRef) {
+      typeRefCsr.emplace(cursor);
+    }
+    return CXChildVisit_Recurse;
+  });
+  ASSERT_TRUE(typeRefCsr.has_value());
+  EXPECT_EQ(from_CXString(clang_getCursorSpelling(*typeRefCsr)),
+            "class ns1::Class1");
+}
+
 class LibclangRewriteTest : public LibclangParseTest {
 public:
   CXRewriter Rew = nullptr;
   std::string Filename;
   CXFile File = nullptr;
 
   void SetUp() override {
     LibclangParseTest::SetUp();

clang/unittests/libclang/TestUtils.h

public:
   template<typename F>
   void Traverse(const F &TraversalFunctor) {
     CXCursor TuCursor = clang_getTranslationUnitCursor(ClangTU);
     std::reference_wrapper<const F> FunctorRef = std::cref(TraversalFunctor);
     clang_visitChildren(TuCursor,
         &TraverseStateless<std::reference_wrapper<const F>>,
         &FunctorRef);
   }
+  static std::string from_CXString(CXString cx_string) {
+    std::string string{clang_getCString(cx_string)};
+    clang_disposeString(cx_string);
+    return string;
+  };
+
 private:
   template<typename TState>
   static CXChildVisitResult TraverseStateless(CXCursor cx, CXCursor parent,
       CXClientData data) {
     TState *State = static_cast<TState*>(data);
     return State->get()(cx, parent);
   }
 };
 
-#endif // LLVM_CLANG_TEST_TESTUTILS_H
+#endif // LLVM_CLANG_TEST_TESTUTILS_H