[clangd] FindTarget: UsingEnumDecl is not an alias

[sammccall]

Summary

Unlike UsingDecl it doesn't name the UsingShadowDecls it emits, so it doesn't
make sense to consider them the same thing. Don't consider the UsingEnumDecl
a target when the UsingShadowDecl is referenced.

[tom-anders]

lgtm, thanks! With this change in place, we could probably ajdust pickDeclToUse in Hover.cpp (introduced in https://reviews.llvm.org/D133664) to also check for UsingDecl instead of BaseUsingDecl, right?

[sammccall]

In D135506#3844919, @tom-anders wrote:

lgtm, thanks! With this change in place, we could probably ajdust pickDeclToUse in Hover.cpp (introduced in https://reviews.llvm.org/D133664) to also check for UsingDecl instead of BaseUsingDecl, right?

Yes, I think so!

clang-tools-extra/clangd/FindTarget.cpp

if (const TypedefNameDecl *TND = dyn_cast<TypedefNameDecl>(D)) {
       add(TND->getUnderlyingType(), Flags | Rel::Underlying);
       Flags |= Rel::Alias; // continue with the alias.
     } else if (const UsingDecl *UD = dyn_cast<UsingDecl>(D)) {
       // no Underlying as this is a non-renaming alias.
       for (const UsingShadowDecl *S : UD->shadows())
         add(S->getUnderlyingDecl(), Flags);
       Flags |= Rel::Alias; // continue with the alias.
     } else if (const UsingEnumDecl *UED = dyn_cast<UsingEnumDecl>(D)) {
-      add(UED->getEnumDecl(), Flags);
-      Flags |= Rel::Alias; // continue with the alias.
+      // UsingEnumDecl is not an alias at all, just a reference.
+      D = UED->getEnumDecl();
     } else if (const auto *NAD = dyn_cast<NamespaceAliasDecl>(D)) {
       add(NAD->getUnderlyingDecl(), Flags | Rel::Underlying);
       Flags |= Rel::Alias; // continue with the alias
     } else if (const UnresolvedUsingValueDecl *UUVD =
                    dyn_cast<UnresolvedUsingValueDecl>(D)) {
       if (Resolver) {
         for (const NamedDecl *Target : Resolver->resolveUsingValueDecl(UUVD)) {
           add(Target, Flags); // no Underlying as this is a non-renaming alias
         }
       }
       Flags |= Rel::Alias; // continue with the alias
     } else if (isa<UnresolvedUsingTypenameDecl>(D)) {
       // FIXME: improve common dependent scope using name lookup in primary
       // templates.
       Flags |= Rel::Alias;
     } else if (const UsingShadowDecl *USD = dyn_cast<UsingShadowDecl>(D)) {
-      // Include the Introducing decl, but don't traverse it. This may end up
-      // including *all* shadows, which we don't want.
+      // Include the introducing UsingDecl, but don't traverse it. This may end
+      // up including *all* shadows, which we don't want.
+      // Don't apply this logic to UsingEnumDecl, which can't easily be
+      // conflated with the aliases it introduces.
+      if (llvm::isa<UsingDecl>(USD->getIntroducer()))
         report(USD->getIntroducer(), Flags | Rel::Alias);
       // Shadow decls are synthetic and not themselves interesting.
       // Record the underlying decl instead, if allowed.
       D = USD->getTargetDecl();
     } else if (const auto *DG = dyn_cast<CXXDeductionGuideDecl>(D)) {
       D = DG->getDeducedTemplate();
     } else if (const ObjCImplementationDecl *IID =
                    dyn_cast<ObjCImplementationDecl>(D)) {
       // Treat ObjC{Interface,Implementation}Decl as if they were a decl/def

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

Code = R"cpp(
     class Foo { public: class foo {}; };
     template <class T> class A : public Foo<T> {
       using typename Foo<T>::foo;
       [[foo]] abc;
     };
   )cpp";
   EXPECT_DECLS("UnresolvedUsingTypeLoc",
                {"using typename Foo<T>::foo", Rel::Alias});
+
+  // Using enum.
+  Flags.push_back("-std=c++20");
+  Code = R"cpp(
+    namespace ns { enum class A { X }; }
+    [[using enum ns::A]];
+  )cpp";
+  EXPECT_DECLS("UsingEnumDecl", "enum class A : int");
+
+  Code = R"cpp(
+    namespace ns { enum class A { X }; }
+    using enum ns::A;
+    auto m = [[X]];
+  )cpp";
+  EXPECT_DECLS("DeclRefExpr", "X");
 }
 
 TEST_F(TargetDeclTest, BaseSpecifier) {
   Code = R"cpp(
     struct X {};
     struct Y : [[private]] X {};
   )cpp";
   EXPECT_DECLS("CXXBaseSpecifier", "struct X");