[clangd] Fix namespace aliases in findExplicitReferences

[merge_guards_bot]

Build result: pass - 59703 tests passed, 0 failed and 762 were skipped.
Log files: console-log.txt, CMakeCache.txt

[kadircet]

This looks good, but it is missing the context. I suppose we were previously not providing any references for namespace aliases, because we were filtering both the alias and the underlying decl?
Could you update the revision summary and/or commit message ?

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

893

nit: I suppose this line checks we are not regressing the "non-alias case", but they are already being tested in previous tests.

[kadircet]

As discussed offline, it might make more sense to fix this in targetDecls itself. Considering how the Alias is handled for typedefs and usings, it feels like this is a mistake for namespace aliases to be marked in that way.

[ilya-biryukov]

In D69624#1728377, @kadircet wrote:

As discussed offline, it might make more sense to fix this in targetDecls itself. Considering how the Alias is handled for typedefs and usings, it feels like this is a mistake for namespace aliases to be marked in that way.

I took another look and it appears the typedefs also have the Alias relation set. So targetDecl is consistent there and the current fix seems ok.

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

893

Yeah, that's just validating that non-aliases also work properly and that's definitely redundant.
I'll keep it as is, it doesn't seem to cause too much noise.

clang-tools-extra/clangd/FindTarget.cpp

private:
   ///     be references. However, declarations can have references inside them,
   ///     e.g. 'namespace foo = std' references namespace 'std' and this
   ///     function will return the corresponding reference.
   llvm::SmallVector<ReferenceLoc, 2> explicitReference(DynTypedNode N) {
     if (auto *D = N.get<Decl>())
       return refInDecl(D);
     if (auto *E = N.get<Expr>())
       return refInExpr(E);
-    if (auto *NNSL = N.get<NestedNameSpecifierLoc>())
-      return {ReferenceLoc{NNSL->getPrefix(), NNSL->getLocalBeginLoc(), false,
-                           explicitReferenceTargets(DynTypedNode::create(
-                               *NNSL->getNestedNameSpecifier()))}};
+    if (auto *NNSL = N.get<NestedNameSpecifierLoc>()) {
+      // (!) 'DeclRelation::Alias' ensures we do not loose namespace aliases.
+      return {ReferenceLoc{
+          NNSL->getPrefix(), NNSL->getLocalBeginLoc(), false,
+          explicitReferenceTargets(
+              DynTypedNode::create(*NNSL->getNestedNameSpecifier()),
+              DeclRelation::Alias)}};
+    }
     if (const TypeLoc *TL = N.get<TypeLoc>())
       return refInTypeLoc(*TL);
     if (const CXXCtorInitializer *CCI = N.get<CXXCtorInitializer>()) {
       // Other type initializers (e.g. base initializer) are handled by visiting
       // the typeLoc.
       if (CCI->isAnyMemberInitializer()) {
         return {ReferenceLoc{NestedNameSpecifierLoc(),
                              CCI->getMemberLocation(),

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

std::pair</*Code*/ llvm::StringRef, /*References*/ llvm::StringRef> Cases[] =
              void foo() {
               class {} $0^x;
               int (*$1^fptr)(int $2^a, int) = nullptr;
              }
            )cpp",
               "0: targets = {x}, decl\n"
               "1: targets = {fptr}, decl\n"
               "2: targets = {a}, decl\n"},
+          // Namespace aliases should be handled properly.
+          {
+              R"cpp(
+                namespace ns { struct Type {} }
+                namespace alias = ns;
+                namespace rec_alias = alias;
+
+                void foo() {
+                  $0^ns::$1^Type $2^a;
+                  $3^alias::$4^Type $5^b;
+                  $6^rec_alias::$7^Type $8^c;
+                }
+           )cpp",
+              "0: targets = {ns}\n"
+              "1: targets = {ns::Type}, qualifier = 'ns::'\n"
+              "2: targets = {a}, decl\n"
+              "3: targets = {alias}\n"
+              "4: targets = {ns::Type}, qualifier = 'alias::'\n"
+              "5: targets = {b}, decl\n"
+              "6: targets = {rec_alias}\n"
+              "7: targets = {ns::Type}, qualifier = 'rec_alias::'\n"
+              "8: targets = {c}, decl\n"},
       };
 
   for (const auto &C : Cases) {
     llvm::StringRef ExpectedCode = C.first;
     llvm::StringRef ExpectedRefs = C.second;
 
     auto Actual =
         annotateReferencesInFoo(llvm::Annotations(ExpectedCode).code());
     EXPECT_EQ(ExpectedCode, Actual.AnnotatedCode);
     EXPECT_EQ(ExpectedRefs, Actual.DumpedReferences) << ExpectedCode;
   }
 }
 
 } // namespace
 } // namespace clangd
 } // namespace clang