[clang] Visit enum base specifiers in libIndex

[kadircet]

Summary

Fixes https://github.com/clangd/clangd/issues/878.

[kadircet]

• Improve tests

[sammccall]

LG. As you pointed out offline it's slightly out-of-order compared to he body but I don't think this matters, and it'd cost a fair bit of complexity to fix.

clang-tools-extra/clangd/unittests/XRefsTests.cpp

const char *Tests[] = {
         // when bar<ns::S> is instantiated?
         template <typename T> void bar(T t) { foo(t); }
         void baz(int x) {
           ns::S s;
           bar<ns::S>(s);
           [[f^oo]](s);
         }
       )cpp",
+
+      // Enum base
+      R"cpp(
+        typedef int $def[[MyTypeD^ef]];
+        enum MyEnum : [[MyTy^peDef]] { };
+      )cpp",
+      R"cpp(
+        typedef int $def[[MyType^Def]];
+        enum MyEnum : [[MyTypeD^ef]];
+      )cpp",
+      R"cpp(
+        using $def[[MyTypeD^ef]] = int;
+        enum MyEnum : [[MyTy^peDef]] { };
+      )cpp",
   };
   for (const char *Test : Tests)
     checkFindRefs(Test);
 }
 
 TEST(FindReferences, IncludeOverrides) {
   llvm::StringRef Test =
       R"cpp(

clang/lib/Index/IndexDecl.cpp

 //===- IndexDecl.cpp - Indexing declarations ------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "IndexingContext.h"
 #include "clang/AST/Attr.h"
+#include "clang/AST/Decl.h"
 #include "clang/AST/DeclVisitor.h"
 #include "clang/Index/IndexDataConsumer.h"
 
 using namespace clang;
 using namespace index;
 
 #define TRY_DECL(D,CALL_EXPR)                                                  \
   do {                                                                         \
if (D->isFreeStanding()) {
         gatherTemplatePseudoOverrides(D, Relations);
         return IndexCtx.handleDecl(D, D->getLocation(), SymbolRoleSet(),
                                    Relations, D->getLexicalDeclContext());
       }
     }
     return true;
   }
 
+  bool VisitEnumDecl(const EnumDecl *ED) {
+    TRY_TO(VisitTagDecl(ED));
+    // Indexing for enumdecl itself is handled inside TagDecl, we just want to
+    // visit integer-base here, which is different than other TagDecl bases.
+    if (auto *TSI = ED->getIntegerTypeSourceInfo())
+      IndexCtx.indexTypeSourceInfo(TSI, ED, ED, /*isBase=*/true);
+    return true;
+  }
+
   bool handleReferencedProtocols(const ObjCProtocolList &ProtList,
                                  const ObjCContainerDecl *ContD,
                                  SourceLocation SuperLoc) {
     ObjCInterfaceDecl::protocol_loc_iterator LI = ProtList.loc_begin();
     for (ObjCInterfaceDecl::protocol_iterator
          I = ProtList.begin(), E = ProtList.end(); I != E; ++I, ++LI) {
       SourceLocation Loc = *LI;
       ObjCProtocolDecl *PD = *I;

clang/unittests/Index/IndexTests.cpp

TEST(IndexTest, RelationBaseOf) {
   auto Index = std::make_shared<Indexer>();
   tooling::runToolOnCode(std::make_unique<IndexAction>(Index), Code);
   // A should not be the base of anything.
   EXPECT_THAT(Index->Symbols,
               Contains(AllOf(QName("A"), HasRole(SymbolRole::Reference),
                              Not(HasRole(SymbolRole::RelationBaseOf)))));
 }
 
+TEST(IndexTest, EnumBase) {
+  std::string Code = R"cpp(
+    typedef int MyTypedef;
+    enum Foo : MyTypedef;
+    enum Foo : MyTypedef {};
+  )cpp";
+  auto Index = std::make_shared<Indexer>();
+  tooling::runToolOnCode(std::make_unique<IndexAction>(Index), Code);
+  EXPECT_THAT(
+      Index->Symbols,
+      AllOf(Contains(AllOf(QName("MyTypedef"), HasRole(SymbolRole::Reference),
+                           WrittenAt(Position(3, 16)))),
+            Contains(AllOf(QName("MyTypedef"), HasRole(SymbolRole::Reference),
+                           WrittenAt(Position(4, 16))))));
+}
 } // namespace
 } // namespace index
 } // namespace clang