[clangd] Find explicit references in the base-specifier of an enum decl

[nridge]

Summary

Partially fixes https://github.com/clangd/clangd/issues/878

[kadircet]

I suppose this is obseleted by https://reviews.llvm.org/D111260

[nridge]

Yep, thanks very much for the more complete fix!

clang-tools-extra/clangd/FindTarget.cpp

explicitReferenceTargets(DynTypedNode N, DeclRelationSet Mask,
   }
   if (!SeenTemplateInstantiations)
     Targets.insert(Targets.end(), TemplatePatterns.begin(),
                    TemplatePatterns.end());
   return Targets;
 }
 
 namespace {
+
+llvm::SmallVector<ReferenceLoc> refInTypeLoc(TypeLoc L,
+                                             const HeuristicResolver *Resolver);
+
 llvm::SmallVector<ReferenceLoc> refInDecl(const Decl *D,
                                           const HeuristicResolver *Resolver) {
   struct Visitor : ConstDeclVisitor<Visitor> {
     Visitor(const HeuristicResolver *Resolver) : Resolver(Resolver) {}
 
     const HeuristicResolver *Resolver;
     llvm::SmallVector<ReferenceLoc> Refs;
 
void VisitNamespaceAliasDecl(const NamespaceAliasDecl *D) {
       VisitNamedDecl(D);
       // Add a non-declaration reference for Target.
       Refs.push_back(ReferenceLoc{D->getQualifierLoc(),
                                   D->getTargetNameLoc(),
                                   /*IsDecl=*/false,
                                   {D->getAliasedNamespace()}});
     }
 
+    void VisitEnumDecl(const EnumDecl *ED) {
+      VisitNamedDecl(ED);
+      // FIXME: Should RecursiveASTVisitor be visiting this TypeLoc instead? (It
+      // doesn't).
+      if (TypeSourceInfo *BaseType = ED->getIntegerTypeSourceInfo()) {
+        llvm::copy(refInTypeLoc(BaseType->getTypeLoc(), Resolver),
+                   std::back_inserter(Refs));
+      }
+    }
+
     void VisitNamedDecl(const NamedDecl *ND) {
       // We choose to ignore {Class, Function, Var, TypeAlias}TemplateDecls. As
       // as their underlying decls, covering the same range, will be visited.
       if (llvm::isa<ClassTemplateDecl>(ND) ||
           llvm::isa<FunctionTemplateDecl>(ND) ||
           llvm::isa<VarTemplateDecl>(ND) ||
           llvm::isa<TypeAliasTemplateDecl>(ND))
         return;

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

)cpp",
         struct $Class_decl[[Derived]] : $Class[[Base]]<$TemplateParameter[[T]]> {
           using $Class[[Base]]<$TemplateParameter[[T]]>::$Field_dependentName[[member]];
 
           void $Method_decl[[method]]() {
             (void)$Field_dependentName[[member]];
           }
         };
       )cpp",
+      // Enum base specifier
+      R"cpp(
+        using $Primitive_decl[[MyTypedef]] = int;
+        enum $Enum_decl[[MyEnum]] : $Primitive[[MyTypedef]] {};
+      )cpp",
   };
   for (const auto &TestCase : TestCases)
     // Mask off scope modifiers to keep the tests manageable.
     // They're tested separately.
     checkHighlightings(TestCase, {}, ~ScopeModifierMask);
 
   checkHighlightings(R"cpp(
     class $Class_decl[[A]] {