[clangd] Report declaration references in findExplicitReferences.

[merge_guards_bot]

Bulid results are available at http://results.llvm-merge-guard.org/Phabricator-36

See http://jenkins.llvm-merge-guard.org/job/Phabricator/36/ for more details.

[ilya-biryukov]

Mostly LG, but please take a look at the NITs and the implementation-related comments.

clang-tools-extra/clangd/FindTarget.cpp

415

This should return SmallVector<ReferenceLoc, 2> now, some declarations can have both decl and non-decl references.

418

We don't need this flag, in every case we now whether a reference points to a decl or not.

439

Similar to DeclaratorDecl, let's handle this in VisitNamedDecl

444

This should be handled in VisitNamedDecl, we should use a helper similar to getQualifier from AST.h to get the qualifier loc instead.

464

NIT: don't use negative flags, they are hard to read. Prefer IsDeclRef

468

Why do we need this in the first place?
Expressions never declare anything, just pass false here

495

Same here: types don't declare anything normally, remove this field and use false directly instead.

669

NIT: please add /*IsDecl=*/ comment here and in other places to make reading the code simpler.

756

NIT: maybe use declaration instead?
ref is definitely redundant, we know we're printing a reference.

clang-tools-extra/clangd/FindTarget.h

90

Initialize to make sure we can't ever have UB when using this struct.

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

528

Why do we need this? Can't we test everything we do by putting into foo?

The original idea was to avoid too much output in the tests by letting the setup code live outside the function that's being annotated.
Any reason why we have to do the full file here?

I know it's a weird limitation, but that's one that was already made and I'd keep it this way if it's possible.

613

We should keep these non-declaration references.
The actual using namespace declaration does not have a name, so we don't report a declaration there

[hokein]

address comments:

• remove the confusing IsDeclRef
• use getQualifier from AST.h

[hokein]

clang-tools-extra/clangd/FindTarget.cpp

415

Can you give some examples? It seems that non-decl references are handled by other refIn* functions.

int Foo = OtherBar; // OtherBar is captured at the momment.

444

good point, didn't aware of this utility method, exposed it in AST.h.

756

changed to decl.

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

528

I tried it but failed.

We can't test the qualified definitions (see example below) if we put everything into function foo (as defining a namespace is not allowed inside a function)

namespace $0^ns {
class $1^Foo {
 void $2^method();
};
void $3^func();
}
void $4^ns::$5^Foo::$6^method() {}
void $7^ns::$8^func() {}

[ilya-biryukov]

clang-tools-extra/clangd/FindTarget.cpp

415

namespace $1[[a]] = $2[[std]];

$1 is a declaration of a namespace alias.
$2 is a reference to namespace std.

[ilya-biryukov]

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

528

Fair point, but this patch does not add support for references in qualifiers of declarations.
I'd keep this change away.

We can totally test all things added by this patch inside the function body.

Could you split the part that adds tests for qualifiers into a separate change?
That would both make the current change more focused and allow to discuss alternatives for the testing story independently of the functionality we're adding here.

[kadircet]

clang-tools-extra/clangd/AST.cpp

110 ↗

(On Diff #225398)

could you move this one back above getQualifierLoc ?

clang-tools-extra/clangd/FindTarget.cpp

415

I was just about to make the same point. After this patch lands I would like to detect using namespaces inside function body, and currently there is no way to distinguish between a usingdirective and a namespacealias. Since both is only referencing the target namespace.

So even if this starts reporting $2 in the comment above, there should be a difference between that and $3 in using namespace $3[[std]];

[ilya-biryukov]

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

846

Could we avoid adding this test in this revision?
We could add it in a follow-up patch along with the fix.

850

Could we avoid reporting destructor references for now? I feel they would create more confusion than bring value.
Mostly worried that they overlap with a reference to the type name and now all client code will probably want to filter out destructor references.

I believe they're not critical to any of the use-cases we have so far, having a `// FIXME: decide how to surface destructors when we need them should be good enough for now

[ilya-biryukov]

clang-tools-extra/clangd/FindTarget.cpp

435

This one is a not a declaration reference.
We could call VisitNamedDecl here to report the actual declaration.

Note that this would require returning two results from this function.

[ilya-biryukov]

clang-tools-extra/clangd/FindTarget.cpp

415

That's intentional, though. When we report references, we deliberately leave out information on where it's coming from - otherwise it's hard to encode it.

However, if we really need that, we could also pass a NamedDecl* when reporting declarations (that would mean a slightly different interface, though).

We still have some complexity budget in findExplicitReferences and we should probably spend it here.
OTOH, adding more stuff will probably bloat it too much, I hope we'll stop there... There will still be cases when one would have to write a separate AST traversal to do more complicated stuff. It's unfortunate that this is twice as expensive, but it shouldn't matter in most cases (e.g. when running inside Tweak::apply)

I'd suggest we keep this patch with IsDecl flag, but happy to look into your use-case with using namespaces more closely...

[hokein]

address comments.

[hokein]

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

850

Agree. it is not needed in rename feature as well, we have a typeLoc occurrence in ~[[Foo]].

[ilya-biryukov]

Mostly NITs from my side, the change LG, thanks!

clang-tools-extra/clangd/FindTarget.cpp

425

Same comment as below: could you say ReferenceLoc explicitly here and in other places?
Plain initializer lists are somewhat hard to parse

437

NIT: maybe put this comment on a previous line?
Should read more naturally.

664

I'd probably suggest to return SmallVector<ReferenceLoc, 2> from all functions, so that they compose better in this situation.

Although Optional<ReferenceLoc> captures the semantics of some of those better, I don't think it's particularly useful at this point.
And having to deconstruct all optionals here leads to a lot of clunky code, it'd be much better if we could keep the structure the same as it's used to be.

665

NIT: add braces around an inner multi-line if?

667

Could we have {ReferenceLoc{ instead of {{?
Plain initializer lists are hard to comprehend, especially when they're nested.

673

Remove this comment? Seems to be a leftover from experiments

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

2280–2281

This looks unrelated. Maybe revert and land separately?

[kadircet]

clang-tools-extra/clangd/FindTarget.cpp

415

as discussed offline, it is a special enough use-case to handle in define-inline.

[hokein]

address remaining nits.

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

2280–2281

This patch also modifies the getNonLocalDeclRefs which is related to the test here. I'd keep the change in this patch as it is minor and NFC.

[ilya-biryukov]

clang-tools-extra/clangd/FindTarget.cpp

494

Could we keep an llvm::Optional<> here in the visitor?
The logic in VisitElaboratedTypeLoc looks cheesy if there's more than 1 reference stored...

The function can keep returning SmallVector, that's totally fine.

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

623

Similar to using namespace, this should be a non-decl reference.

[hokein]

address comments.

[ilya-biryukov]

LGTM. Many thanks!

[merge_guards_bot]

Build result: fail - 33449 tests passed, 2 failed and 463 were skipped.

failed: LLVM.tools/llvm-ar/mri-utf8.test
failed: LLVM.tools/llvm-objdump/X86/disassemble-functions.test

Log files: cmake-log.txt, ninja_check_all-log.txt, CMakeCache.txt

clang-tools-extra/clangd/FindTarget.h

 /// Information about a reference written in the source code, independent of the
 /// actual AST node that this reference lives in.
 /// Useful for tools that are source-aware, e.g. refactorings.
 struct ReferenceLoc {
   /// Contains qualifier written in the code, if any, e.g. 'ns::' for 'ns::foo'.
   NestedNameSpecifierLoc Qualifier;
   /// Start location of the last name part, i.e. 'foo' in 'ns::foo<int>'.
   SourceLocation NameLoc;
+  /// True if the reference is a declaration or definition;
+  bool IsDecl;
   // FIXME: add info about template arguments.
   /// A list of targets referenced by this name. Normally this has a single
   /// element, but multiple is also possible, e.g. in case of using declarations
   /// or unresolved overloaded functions.
   /// For dependent and unresolved references, Targets can also be empty.
   llvm::SmallVector<const NamedDecl *, 1> Targets;
 };
 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, ReferenceLoc R);

clang-tools-extra/clangd/FindTarget.cpp

for (auto &D : Decls) {
     Targets.push_back(llvm::cast<NamedDecl>(D.first));
   }
   if (!SeenTemplateInstantiations)
     Targets.insert(Targets.end(), TemplatePatterns.begin(),
                    TemplatePatterns.end());
   return Targets;
 }
 
 Optional<ReferenceLoc> refInDecl(const Decl *D) {
   struct Visitor : ConstDeclVisitor<Visitor> {
     llvm::Optional<ReferenceLoc> Ref;
-
+    bool DeclRef = true;
     void VisitUsingDirectiveDecl(const UsingDirectiveDecl *D) {
       Ref = ReferenceLoc{D->getQualifierLoc(),
                          D->getIdentLocation(),
+                         DeclRef,
                          {D->getNominatedNamespaceAsWritten()}};
     }
 
     void VisitUsingDecl(const UsingDecl *D) {
-      Ref = ReferenceLoc{D->getQualifierLoc(), D->getLocation(),
+      Ref = ReferenceLoc{D->getQualifierLoc(), D->getLocation(), DeclRef,
                          explicitReferenceTargets(DynTypedNode::create(*D),
                                                   DeclRelation::Underlying)};
     }
 
     void VisitNamespaceAliasDecl(const NamespaceAliasDecl *D) {
       Ref = ReferenceLoc{D->getQualifierLoc(),
                          D->getTargetNameLoc(),
+                         DeclRef,
                          {D->getAliasedNamespace()}};
     }
+
+    void VisitTagDecl(const TagDecl *ND) {
+      Ref =
+          ReferenceLoc{ND->getQualifierLoc(), ND->getLocation(), DeclRef, {ND}};
+    }
+
+    void VisitDeclaratorDecl(const DeclaratorDecl *ND) {
+      Ref =
+          ReferenceLoc{ND->getQualifierLoc(), ND->getLocation(), DeclRef, {ND}};
+    }
+
+    void VisitNamedDecl(const NamedDecl *ND) {
+      Ref = ReferenceLoc{
+          NestedNameSpecifierLoc(), ND->getLocation(), DeclRef, {ND}};
+    }
   };
 
   Visitor V;
   V.Visit(D);
   return V.Ref;
 }
 
 Optional<ReferenceLoc> refInExpr(const Expr *E) {
   struct Visitor : ConstStmtVisitor<Visitor> {
     // FIXME: handle more complicated cases, e.g. ObjC, designated initializers.
     llvm::Optional<ReferenceLoc> Ref;
-
+    bool NotDeclRef = false;
     void VisitDeclRefExpr(const DeclRefExpr *E) {
-      Ref = ReferenceLoc{
-          E->getQualifierLoc(), E->getNameInfo().getLoc(), {E->getFoundDecl()}};
+      Ref = ReferenceLoc{E->getQualifierLoc(),
+                         E->getNameInfo().getLoc(),
+                         NotDeclRef,
+                         {E->getFoundDecl()}};
     }
 
     void VisitMemberExpr(const MemberExpr *E) {
       Ref = ReferenceLoc{E->getQualifierLoc(),
                          E->getMemberNameInfo().getLoc(),
+                         NotDeclRef,
                          {E->getFoundDecl()}};
     }
 
     void VisitOverloadExpr(const OverloadExpr *E) {
       Ref = ReferenceLoc{E->getQualifierLoc(), E->getNameInfo().getLoc(),
+                         NotDeclRef,
                          llvm::SmallVector<const NamedDecl *, 1>(
                              E->decls().begin(), E->decls().end())};
     }
   };
 
   Visitor V;
   V.Visit(E);
   return V.Ref;
 }
 
 Optional<ReferenceLoc> refInTypeLoc(TypeLoc L) {
   struct Visitor : TypeLocVisitor<Visitor> {
     llvm::Optional<ReferenceLoc> Ref;
-
+    bool NotDeclRef = false;
     void VisitElaboratedTypeLoc(ElaboratedTypeLoc L) {
       // We only know about qualifier, rest if filled by inner locations.
       Visit(L.getNamedTypeLoc().getUnqualifiedLoc());
       // Fill in the qualifier.
       if (!Ref)
         return;
       assert(!Ref->Qualifier.hasQualifier() && "qualifier already set");
       Ref->Qualifier = L.getQualifierLoc();
     }
 
     void VisitTagTypeLoc(TagTypeLoc L) {
-      Ref =
-          ReferenceLoc{NestedNameSpecifierLoc(), L.getNameLoc(), {L.getDecl()}};
+      Ref = ReferenceLoc{
+          NestedNameSpecifierLoc(), L.getNameLoc(), NotDeclRef, {L.getDecl()}};
     }
 
     void VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc L) {
-      Ref =
-          ReferenceLoc{NestedNameSpecifierLoc(), L.getNameLoc(), {L.getDecl()}};
+      Ref = ReferenceLoc{
+          NestedNameSpecifierLoc(), L.getNameLoc(), NotDeclRef, {L.getDecl()}};
     }
 
     void VisitTemplateSpecializationTypeLoc(TemplateSpecializationTypeLoc L) {
       // We must ensure template type aliases are included in results if they
       // were written in the source code, e.g. in
       //    template <class T> using valias = vector<T>;
       //    ^valias<int> x;
       // 'explicitReferenceTargets' will return:
       //    1. valias with mask 'Alias'.
       //    2. 'vector<int>' with mask 'Underlying'.
       //  we want to return only #1 in this case.
       Ref = ReferenceLoc{
-          NestedNameSpecifierLoc(), L.getTemplateNameLoc(),
+          NestedNameSpecifierLoc(), L.getTemplateNameLoc(), NotDeclRef,
           explicitReferenceTargets(DynTypedNode::create(L.getType()),
                                    DeclRelation::Alias)};
     }
     void VisitDeducedTemplateSpecializationTypeLoc(
         DeducedTemplateSpecializationTypeLoc L) {
       Ref = ReferenceLoc{
-          NestedNameSpecifierLoc(), L.getNameLoc(),
+          NestedNameSpecifierLoc(), L.getNameLoc(), NotDeclRef,
           explicitReferenceTargets(DynTypedNode::create(L.getType()),
                                    DeclRelation::Alias)};
     }
 
     void VisitDependentTemplateSpecializationTypeLoc(
         DependentTemplateSpecializationTypeLoc L) {
       Ref = ReferenceLoc{
-          L.getQualifierLoc(), L.getTemplateNameLoc(),
+          L.getQualifierLoc(), L.getTemplateNameLoc(), NotDeclRef,
           explicitReferenceTargets(DynTypedNode::create(L.getType()))};
     }
 
     void VisitDependentNameTypeLoc(DependentNameTypeLoc L) {
       Ref = ReferenceLoc{
-          L.getQualifierLoc(), L.getNameLoc(),
+          L.getQualifierLoc(), L.getNameLoc(), NotDeclRef,
           explicitReferenceTargets(DynTypedNode::create(L.getType()))};
     }
 
     void VisitTypedefTypeLoc(TypedefTypeLoc L) {
-      Ref = ReferenceLoc{
-          NestedNameSpecifierLoc(), L.getNameLoc(), {L.getTypedefNameDecl()}};
+      Ref = ReferenceLoc{NestedNameSpecifierLoc(),
+                         L.getNameLoc(),
+                         NotDeclRef,
+                         {L.getTypedefNameDecl()}};
     }
   };
 
   Visitor V;
   V.Visit(L.getUnqualifiedLoc());
   return V.Ref;
 }
 
public:
   // TemplateArgumentLoc is the only way to get locations for references to
   // template template parameters.
   bool TraverseTemplateArgumentLoc(TemplateArgumentLoc A) {
     switch (A.getArgument().getKind()) {
     case TemplateArgument::Template:
     case TemplateArgument::TemplateExpansion:
       reportReference(ReferenceLoc{A.getTemplateQualifierLoc(),
                                    A.getTemplateNameLoc(),
+                                   false,
                                    {A.getArgument()
                                         .getAsTemplateOrTemplatePattern()
                                         .getAsTemplateDecl()}},
                       DynTypedNode::create(A.getArgument()));
       break;
     case TemplateArgument::Declaration:
       break; // FIXME: can this actually happen in TemplateArgumentLoc?
     case TemplateArgument::Integral:
private:
   ///     e.g. 'namespace foo = std' references namespace 'std' and this
   ///     function will return the corresponding reference.
   llvm::Optional<ReferenceLoc> 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(),
+      return ReferenceLoc{NNSL->getPrefix(), NNSL->getLocalBeginLoc(), false,
                           explicitReferenceTargets(DynTypedNode::create(
                               *NNSL->getNestedNameSpecifier()))};
     if (const TypeLoc *TL = N.get<TypeLoc>())
       return refInTypeLoc(*TL);
     if (const CXXCtorInitializer *CCI = N.get<CXXCtorInitializer>()) {
       if (CCI->isBaseInitializer())
         return refInTypeLoc(CCI->getBaseClassLoc());
       assert(CCI->isAnyMemberInitializer());
       return ReferenceLoc{NestedNameSpecifierLoc(),
                           CCI->getMemberLocation(),
+                          false,
                           {CCI->getAnyMember()}};
     }
     // We do not have location information for other nodes (QualType, etc)
     return llvm::None;
   }
 
   void visitNode(DynTypedNode N) {
     auto Ref = explicitReference(N);
     if (!Ref)
       return;
     reportReference(*Ref, N);
   }
llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, ReferenceLoc R) {
   }
   OS << "}";
   if (R.Qualifier) {
     OS << ", qualifier = '";
     R.Qualifier.getNestedNameSpecifier()->print(OS,
                                                 PrintingPolicy(LangOptions()));
     OS << "'";
   }
+  if (R.IsDecl)
+    OS << ", decl ref";
   return OS;
 }
 
 } // namespace clangd
 } // namespace clang

clang-tools-extra/clangd/XRefs.cpp

 
 llvm::DenseSet<const Decl *> getNonLocalDeclRefs(ParsedAST &AST,
                                                  const FunctionDecl *FD) {
   if (!FD->hasBody())
     return {};
   llvm::DenseSet<const Decl *> DeclRefs;
   findExplicitReferences(FD, [&](ReferenceLoc Ref) {
     for (const Decl *D : Ref.Targets) {
-      if (!index::isFunctionLocalSymbol(D) && !D->isTemplateParameter())
+      if (!index::isFunctionLocalSymbol(D) && !D->isTemplateParameter() &&
+          !Ref.IsDecl)
         DeclRefs.insert(D);
     }
   });
   return DeclRefs;
 }
 } // namespace clangd
 } // namespace clang

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

AllRefs annotateReferencesInFoo(llvm::StringRef Code) {
     if (auto *T = llvm::dyn_cast<FunctionTemplateDecl>(TestDecl))
       TestDecl = T->getTemplatedDecl();
     auto &Func = llvm::cast<FunctionDecl>(*TestDecl);
 
     std::vector<ReferenceLoc> Refs;
     findExplicitReferences(Func.getBody(), [&Refs](ReferenceLoc R) {
       Refs.push_back(std::move(R));
     });
+    return dumpReferences(std::move(Refs), Code, AST.getSourceManager());
+  }
+
+  /// Similar to annotateReferencesInFoo, but finds all references in the main
+  /// AST.
+  AllRefs annotateReferencesInMainAST(llvm::StringRef Code) {
+    TestTU TU;
+    TU.Code = Code;
+
+    auto AST = TU.build();
+    std::vector<ReferenceLoc> Refs;
+    for (const auto *ToplLevelDecl : AST.getLocalTopLevelDecls()) {
+      findExplicitReferences(ToplLevelDecl, [&Refs](ReferenceLoc R) {
+        Refs.push_back(std::move(R));
+      });
+    }
+    return dumpReferences(std::move(Refs), Code, AST.getSourceManager());
+  }
 
-    auto &SM = AST.getSourceManager();
+private:
+  AllRefs dumpReferences(std::vector<ReferenceLoc> Refs, llvm::StringRef Code,
+                         const SourceManager &SM) {
     llvm::sort(Refs, [&](const ReferenceLoc &L, const ReferenceLoc &R) {
       return SM.isBeforeInTranslationUnit(L.NameLoc, R.NameLoc);
     });
 
     std::string AnnotatedCode;
     unsigned NextCodeChar = 0;
     for (unsigned I = 0; I < Refs.size(); ++I) {
       auto &R = Refs[I];
std::pair</*Code*/ llvm::StringRef, /*References*/ llvm::StringRef> Cases[] =
           {R"cpp(
           namespace ns {}
           namespace alias = ns;
           void foo() {
             using namespace $0^ns;
             using namespace $1^alias;
           }
         )cpp",
-           "0: targets = {ns}\n"
-           "1: targets = {alias}\n"},
+           "0: targets = {ns}, decl ref\n"
+           "1: targets = {alias}, decl ref\n"},
           // Using declarations.
           {R"cpp(
           namespace ns { int global; }
           void foo() {
             using $0^ns::$1^global;
           }
         )cpp",
            "0: targets = {ns}\n"
-           "1: targets = {ns::global}, qualifier = 'ns::'\n"},
+           "1: targets = {ns::global}, qualifier = 'ns::', decl ref\n"},
           // Simple types.
           {R"cpp(
          struct Struct { int a; };
          using Typedef = int;
          void foo() {
-           $0^Struct x;
-           $1^Typedef y;
-           static_cast<$2^Struct*>(0);
+           $0^Struct $1^x;
+           $2^Typedef $3^y;
+           static_cast<$4^Struct*>(0);
          }
        )cpp",
            "0: targets = {Struct}\n"
-           "1: targets = {Typedef}\n"
-           "2: targets = {Struct}\n"},
+           "1: targets = {x}, decl ref\n"
+           "2: targets = {Typedef}\n"
+           "3: targets = {y}, decl ref\n"
+           "4: targets = {Struct}\n"},
           // Name qualifiers.
           {R"cpp(
          namespace a { namespace b { struct S { typedef int type; }; } }
          void foo() {
-           $0^a::$1^b::$2^S x;
-           using namespace $3^a::$4^b;
-           $5^S::$6^type y;
+           $0^a::$1^b::$2^S $3^x;
+           using namespace $4^a::$5^b;
+           $6^S::$7^type $8^y;
          }
         )cpp",
            "0: targets = {a}\n"
            "1: targets = {a::b}, qualifier = 'a::'\n"
            "2: targets = {a::b::S}, qualifier = 'a::b::'\n"
-           "3: targets = {a}\n"
-           "4: targets = {a::b}, qualifier = 'a::'\n"
-           "5: targets = {a::b::S}\n"
-           "6: targets = {a::b::S::type}, qualifier = 'struct S::'\n"},
+           "3: targets = {x}, decl ref\n"
+           "4: targets = {a}\n"
+           "5: targets = {a::b}, qualifier = 'a::', decl ref\n"
+           "6: targets = {a::b::S}\n"
+           "7: targets = {a::b::S::type}, qualifier = 'struct S::'\n"
+           "8: targets = {y}, decl ref\n"},
           // Simple templates.
           {R"cpp(
           template <class T> struct vector { using value_type = T; };
           template <> struct vector<bool> { using value_type = bool; };
           void foo() {
-            $0^vector<int> vi;
-            $1^vector<bool> vb;
+            $0^vector<int> $1^vi;
+            $2^vector<bool> $3^vb;
           }
         )cpp",
            "0: targets = {vector<int>}\n"
-           "1: targets = {vector<bool>}\n"},
+           "1: targets = {vi}, decl ref\n"
+           "2: targets = {vector<bool>}\n"
+           "3: targets = {vb}, decl ref\n"},
           // Template type aliases.
           {R"cpp(
             template <class T> struct vector { using value_type = T; };
             template <> struct vector<bool> { using value_type = bool; };
             template <class T> using valias = vector<T>;
             void foo() {
-              $0^valias<int> vi;
-              $1^valias<bool> vb;
+              $0^valias<int> $1^vi;
+              $2^valias<bool> $3^vb;
             }
           )cpp",
            "0: targets = {valias}\n"
-           "1: targets = {valias}\n"},
+           "1: targets = {vi}, decl ref\n"
+           "2: targets = {valias}\n"
+           "3: targets = {vb}, decl ref\n"},
           // MemberExpr should know their using declaration.
           {R"cpp(
             struct X { void func(int); }
             struct Y : X {
               using X::func;
             };
             void foo(Y y) {
               $0^y.$1^func(1);
std::pair</*Code*/ llvm::StringRef, /*References*/ llvm::StringRef> Cases[] =
           // No references from implicit nodes.
           {R"cpp(
             struct vector {
               int *begin();
               int *end();
             };
 
             void foo() {
-              for (int x : $0^vector()) {
-                $1^x = 10;
+              for (int $0^x : $1^vector()) {
+                $2^x = 10;
               }
             }
         )cpp",
-           "0: targets = {vector}\n"
-           "1: targets = {x}\n"},
+           "0: targets = {x}, decl ref\n"
+           "1: targets = {vector}\n"
+           "2: targets = {x}\n"},
           // Handle UnresolvedLookupExpr.
           {R"cpp(
             namespace ns1 { void func(char*); }
             namespace ns2 { void func(int*); }
             using namespace ns1;
             using namespace ns2;
 
             template <class T>
std::pair</*Code*/ llvm::StringRef, /*References*/ llvm::StringRef> Cases[] =
            "1: targets = {X::func, X::func}\n"
            "2: targets = {t}\n"},
           // Type template parameters.
           {R"cpp(
             template <class T>
             void foo() {
               static_cast<$0^T>(0);
               $1^T();
-              $2^T t;
+              $2^T $3^t;
             }
         )cpp",
            "0: targets = {T}\n"
            "1: targets = {T}\n"
-           "2: targets = {T}\n"},
+           "2: targets = {T}\n"
+           "3: targets = {t}, decl ref\n"},
           // Non-type template parameters.
           {R"cpp(
             template <int I>
             void foo() {
-              int x = $0^I;
+              int $0^x = $1^I;
             }
         )cpp",
-           "0: targets = {I}\n"},
+           "0: targets = {x}, decl ref\n"
+           "1: targets = {I}\n"},
           // Template template parameters.
           {R"cpp(
             template <class T> struct vector {};
 
             template <template<class> class TT, template<class> class ...TP>
             void foo() {
-              $0^TT<int> x;
-              $1^foo<$2^TT>();
-              $3^foo<$4^vector>()
-              $5^foo<$6^TP...>();
+              $0^TT<int> $1^x;
+              $2^foo<$3^TT>();
+              $4^foo<$5^vector>()
+              $6^foo<$7^TP...>();
             }
         )cpp",
            "0: targets = {TT}\n"
-           "1: targets = {foo}\n"
-           "2: targets = {TT}\n"
-           "3: targets = {foo}\n"
-           "4: targets = {vector}\n"
-           "5: targets = {foo}\n"
-           "6: targets = {TP}\n"},
+           "1: targets = {x}, decl ref\n"
+           "2: targets = {foo}\n"
+           "3: targets = {TT}\n"
+           "4: targets = {foo}\n"
+           "5: targets = {vector}\n"
+           "6: targets = {foo}\n"
+           "7: targets = {TP}\n"},
           // Non-type template parameters with declarations.
           {R"cpp(
             int func();
             template <int(*)()> struct wrapper {};
 
             template <int(*FuncParam)()>
             void foo() {
-              $0^wrapper<$1^func> w;
-              $2^FuncParam();
+              $0^wrapper<$1^func> $2^w;
+              $3^FuncParam();
             }
         )cpp",
            "0: targets = {wrapper<&func>}\n"
            "1: targets = {func}\n"
-           "2: targets = {FuncParam}\n"},
+           "2: targets = {w}, decl ref\n"
+           "3: targets = {FuncParam}\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;
   }
 }
 
+TEST_F(FindExplicitReferencesTest, DeclReference) {
+  std::pair</*Code*/ llvm::StringRef, /*References*/ llvm::StringRef> Cases[] =
+      {
+          // simple declarations.
+          {R"cpp(
+             class $0^Foo { $1^Foo(); $2^~$3^Foo(); int $4^field; };
+             int $5^Var;
+             void $6^Fun() {}
+             enum $7^E { $8^ABC };
+             typedef int $9^INT;
+             using $10^INT2 = int;
+             template<typename $11^T>
+             // FIXME: the duplicated locations are from FunctionTemplateDecl and
+             // the underlying FunctionDecl. we should report just one.
+             void $12^$13^F() {}
+           )cpp",
+           "0: targets = {Foo}, decl ref\n"
+           "1: targets = {Foo::Foo}, decl ref\n"
+           "2: targets = {Foo::~Foo}, decl ref\n"
+           "3: targets = {Foo}\n"
+           "4: targets = {Foo::field}, decl ref\n"
+           "5: targets = {Var}, decl ref\n"
+           "6: targets = {Fun}, decl ref\n"
+           "7: targets = {E}, decl ref\n"
+           "8: targets = {ABC}, decl ref\n"
+           "9: targets = {INT}, decl ref\n"
+           "10: targets = {INT2}, decl ref\n"
+           "11: targets = {T}, decl ref\n"
+           "12: targets = {F}, decl ref\n"
+           "13: targets = {F}, decl ref\n"},
+          // declarations with qualifiers.
+          {R"cpp(
+             namespace $0^ns {
+             class $1^Foo {
+               void $2^method();
+             };
+             void $3^func();
+             }
+             void $4^ns::$5^Foo::$6^method() {}
+             void $7^ns::$8^func() {}
+           )cpp",
+           "0: targets = {ns}, decl ref\n"
+           "1: targets = {ns::Foo}, decl ref\n"
+           "2: targets = {ns::Foo::method}, decl ref\n"
+           "3: targets = {ns::func}, decl ref\n"
+           "4: targets = {ns}\n"
+           "5: targets = {ns::Foo}, qualifier = 'ns::'\n"
+           "6: targets = {ns::Foo::method}, qualifier = 'ns::class Foo::', "
+           "decl ref\n"
+           "7: targets = {ns}\n"
+           "8: targets = {ns::func}, qualifier = 'ns::', decl ref\n"},
+      };
+
+  for (const auto &C : Cases) {
+    llvm::StringRef ExpectedCode = C.first;
+    llvm::StringRef ExpectedRefs = C.second;
+
+    auto Actual =
+        annotateReferencesInMainAST(llvm::Annotations(ExpectedCode).code());
+    EXPECT_EQ(ExpectedCode, Actual.AnnotatedCode);
+    EXPECT_EQ(ExpectedRefs, Actual.DumpedReferences) << ExpectedCode;
+  }
+}
+
 } // namespace
 } // namespace clangd
 } // namespace clang

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

for (const Case &C : Cases) {
     ASSERT_NE(FD, nullptr);
 
     auto NonLocalDeclRefs = getNonLocalDeclRefs(AST, FD);
     std::vector<std::string> Names;
     for (const Decl *D : NonLocalDeclRefs) {
       if (const auto *ND = llvm::dyn_cast<NamedDecl>(D))
         Names.push_back(ND->getQualifiedNameAsString());
     }
-    EXPECT_THAT(Names, UnorderedElementsAreArray(C.ExpectedDecls));
+    EXPECT_THAT(Names, UnorderedElementsAreArray(C.ExpectedDecls))
+        << File.code();
   }
 }
 
 } // namespace
 } // namespace clangd
 } // namespace clang