[clangd] Extend findTarget()'s dependent name heuristic to handle enumerators

[sammccall]

Thanks! Just a couple of Qs...

clang-tools-extra/clangd/FindTarget.cpp

88

Is this the bit that "breaks" the dependence? getDecl() works even if the type might ultimately correspond to a different decl?

It's not obvious to me where the magic happens, so wherever it is, maybe add a comment :-)

88

The actual lookup doesn't do anything subtle in this case (no dependent base lookup, failing to match IsArrow isn't possible).

What do you think about just calling Decl->lookup() here and early returning, not bothering with the generalization of lookupDependentName? (I find the mix of behavior in that function a little hard to get my head around)

[nridge]

Address review comments

[sammccall]

Thanks!

clang-tools-extra/clangd/FindTarget.cpp

82

or auto result = ET->getDecl()->lookup(...); return {result.begin(), result.end()}

[nridge]

Address final review comment

clang-tools-extra/clangd/FindTarget.cpp

 #include "clang/Basic/OperatorKinds.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/Specifiers.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/raw_ostream.h"
+#include <iterator>
 #include <utility>
 #include <vector>
 
 namespace clang {
 namespace clangd {
 namespace {
 using ast_type_traits::DynTypedNode;
 

 // name (e.g. if it's an operator name), but the caller may not have
 // access to an ASTContext.
 std::vector<const NamedDecl *> getMembersReferencedViaDependentName(
     const Type *T,
     llvm::function_ref<DeclarationName(ASTContext &)> NameFactory,
     bool IsNonstaticMember) {
   if (!T)
     return {};
+  if (auto *ET = T->getAs<EnumType>()) {
+    auto Result =
+        ET->getDecl()->lookup(NameFactory(ET->getDecl()->getASTContext()));
+    return {Result.begin(), Result.end()};
+  }
   if (auto *ICNT = T->getAs<InjectedClassNameType>()) {
     T = ICNT->getInjectedSpecializationType().getTypePtrOrNull();
   }
   auto *TST = T->getAs<TemplateSpecializationType>();
   if (!TST)
     return {};
   const ClassTemplateDecl *TD = dyn_cast_or_null<ClassTemplateDecl>(
       TST->getTemplateName().getAsTemplateDecl());
   if (!TD)
     return {};
   CXXRecordDecl *RD = TD->getTemplatedDecl();
   if (!RD->hasDefinition())

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

const char *Tests[] = {
         template <typename> struct S { void [[foo]]() {} };
         template <typename T> struct unique_ptr {
           T* operator->();
         };
         template <typename T>
         void test(unique_ptr<S<T>>& V) {
           V->fo^o();
         }
+      )cpp",
+
+      R"cpp(// Heuristic resolution of dependent enumerator
+        template <typename T>
+        struct Foo {
+          enum class E { [[A]], B };
+          E e = E::A^;
+        };
       )cpp"};
   for (const char *Test : Tests) {
     Annotations T(Test);
     llvm::Optional<Range> WantDecl;
     llvm::Optional<Range> WantDef;
     if (!T.ranges().empty())
       WantDecl = WantDef = T.range();
     if (!T.ranges("decl").empty())