[clangd] Respect ReferencesParams.context.includeDeclarations

[sammccall]

Summary

Unfortunately this treats overrides declarations as declarations, not as
references. I don't plan to land this until I have a fix for that issue.

[kbobyrev]

Thanks, LGTM with a couple of nits.

clang-tools-extra/clangd/XRefs.h

23

nit: are these two needed? I can't see any usages of symbols defined there.

84

nit: Plain means neither Declaration nor Definition, right? Maybe None then?

[sammccall]

clang-tools-extra/clangd/XRefs.h

84

Haha, this is actually unused.

clang-tools-extra/clangd/ClangdLSPServer.cpp

 // FIXME: This function needs to be properly tested.
 void ClangdLSPServer::onChangeConfiguration(
     const DidChangeConfigurationParams &Params) {
   applyConfiguration(Params.settings);
 }
 
 void ClangdLSPServer::onReference(const ReferenceParams &Params,
                                   Callback<std::vector<Location>> Reply) {
-  Server->findReferences(Params.textDocument.uri.file(), Params.position,
-                         Opts.CodeComplete.Limit,
-                         [Reply = std::move(Reply)](
-                             llvm::Expected<ReferencesResult> Refs) mutable {
-                           if (!Refs)
-                             return Reply(Refs.takeError());
-                           return Reply(std::move(Refs->References));
-                         });
+  Server->findReferences(
+      Params.textDocument.uri.file(), Params.position, Opts.CodeComplete.Limit,
+      [Reply = std::move(Reply),
+       IncludeDecl(Params.context.includeDeclaration)](
+        // Filter out declarations if the client asked.
+        std::vector<Location> Result;
+        Result.reserve(Refs->References.size());
+        for (auto &Ref : Refs->References) {
+          bool IsDecl = Ref.Attributes & ReferencesResult::Declaration;
+          if (IncludeDecl || !IsDecl)
+            Result.push_back(std::move(Ref.Loc));
+        }
+        return Reply(std::move(Result));
 }
 
 void ClangdLSPServer::onGoToImplementation(
     const TextDocumentPositionParams &Params,
     Callback<std::vector<Location>> Reply) {
   Server->findImplementations(
       Params.textDocument.uri.file(), Params.position,
       [Reply = std::move(Reply)](

clang-tools-extra/clangd/Protocol.h

struct CallHierarchyOutgoingCall {
   CallHierarchyItem to;
 
   /// The range at which this item is called.
   /// This is the range relative to the caller, and not `To`.
   std::vector<Range> fromRanges;
 };
 llvm::json::Value toJSON(const CallHierarchyOutgoingCall &);
 
+struct ReferenceContext {
+  /// Include the declaration of the current symbol.
+  bool includeDeclaration = false;
+};
+
 struct ReferenceParams : public TextDocumentPositionParams {
-  // For now, no options like context.includeDeclaration are supported.
+  ReferenceContext context;
 };
 bool fromJSON(const llvm::json::Value &, ReferenceParams &, llvm::json::Path);
 
 /// Clangd extension: indicates the current state of the file in clangd,
 /// sent from server via the `textDocument/clangd.fileStatus` notification.
 struct FileStatus {
   /// The text document's URI.
   URIForFile uri;

clang-tools-extra/clangd/Protocol.cpp

 
 bool fromJSON(const llvm::json::Value &Params,
               ResolveTypeHierarchyItemParams &R, llvm::json::Path P) {
   llvm::json::ObjectMapper O(Params, P);
   return O && O.map("item", R.item) && O.map("resolve", R.resolve) &&
          O.map("direction", R.direction);
 }
 
+bool fromJSON(const llvm::json::Value &Params, ReferenceContext &R,
+              llvm::json::Path P) {
+  llvm::json::ObjectMapper O(Params, P);
+  return O && O.mapOptional("includeDeclaration", R.includeDeclaration);
+}
+
 bool fromJSON(const llvm::json::Value &Params, ReferenceParams &R,
               llvm::json::Path P) {
   TextDocumentPositionParams &Base = R;
-  return fromJSON(Params, Base, P);
+  llvm::json::ObjectMapper O(Params, P);
+  return fromJSON(Params, Base, P) && O && O.mapOptional("context", R.context);
 }
 
 llvm::json::Value toJSON(SymbolTag Tag) {
   return llvm::json::Value{static_cast<int>(Tag)};
 }
 
 llvm::json::Value toJSON(const CallHierarchyItem &I) {
   llvm::json::Object Result{{"name", I.name},

clang-tools-extra/clangd/XRefs.h

 
 #include "Protocol.h"
 #include "SourceCode.h"
 #include "index/Index.h"
 #include "index/SymbolLocation.h"
 #include "support/Path.h"
 #include "clang/AST/ASTTypeTraits.h"
 #include "clang/AST/Type.h"
 #include "clang/Format/Format.h"
 #include "clang/Index/IndexSymbol.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/Support/raw_ostream.h"
 #include <vector>
 
 namespace clang {
 namespace syntax {
 class Token;

 /// Get all document links
 std::vector<DocumentLink> getDocumentLinks(ParsedAST &AST);
 
 /// Returns highlights for all usages of a symbol at \p Pos.
 std::vector<DocumentHighlight> findDocumentHighlights(ParsedAST &AST,
                                                       Position Pos);
 
 struct ReferencesResult {
-  std::vector<Location> References;
+  // Bitmask describing whether the occurrence is a declaration, definition etc.
+  enum ReferenceAttributes : unsigned {
+    Declaration = 1 << 0,
+    Definition = 1 << 1,
+  };
+  struct Reference {
+    Location Loc;
+    unsigned Attributes = 0;
+  };
+  std::vector<Reference> References;
   bool HasMore = false;
 };
+llvm::raw_ostream &operator<<(llvm::raw_ostream &,
+                              const ReferencesResult::Reference &);
 
 /// Returns implementations at a specified \p Pos:
 ///   - overrides for a virtual method;
 ///   - subclasses for a base class;
 std::vector<LocatedSymbol> findImplementations(ParsedAST &AST, Position Pos,
                                                const SymbolIndex *Index);
 
 /// Returns references of the symbol at a specified \p Pos.

clang-tools-extra/clangd/XRefs.cpp

ReferencesResult findReferences(ParsedAST &AST, Position Pos, uint32_t Limit,
   if (Macro) {
     // Handle references to macro.
     if (auto MacroSID = getSymbolID(Macro->Name, Macro->Info, SM)) {
       // Collect macro references from main file.
       const auto &IDToRefs = AST.getMacros().MacroRefs;
       auto Refs = IDToRefs.find(MacroSID);
       if (Refs != IDToRefs.end()) {
         for (const auto &Ref : Refs->second) {
-          Location Result;
-          Result.range = Ref.Rng;
-          Result.uri = URIMainFile;
+          ReferencesResult::Reference Result;
+          Result.Loc.range = Ref.Rng;
+          Result.Loc.uri = URIMainFile;
+          if (Ref.IsDefinition) {
+            Result.Attributes |= ReferencesResult::Declaration;
+            Result.Attributes |= ReferencesResult::Definition;
+          }
           Results.References.push_back(std::move(Result));
         }
       }
       Req.IDs.insert(MacroSID);
     }
   } else {
     // Handle references to Decls.
 
if (Macro) {
     MainFileRefs.erase(std::unique(MainFileRefs.begin(), MainFileRefs.end(),
                                    [](const ReferenceFinder::Reference &L,
                                       const ReferenceFinder::Reference &R) {
                                      return L.SpelledTok.location() ==
                                             R.SpelledTok.location();
                                    }),
                        MainFileRefs.end());
     for (const auto &Ref : MainFileRefs) {
-      Location Result;
-      Result.range = Ref.range(SM);
-      Result.uri = URIMainFile;
+      ReferencesResult::Reference Result;
+      Result.Loc.range = Ref.range(SM);
+      Result.Loc.uri = URIMainFile;
+      if (Ref.Role & static_cast<unsigned>(index::SymbolRole::Declaration))
+        Result.Attributes |= ReferencesResult::Declaration;
+      // clang-index doesn't report definitions as declarations, but they are.
+      if (Ref.Role & static_cast<unsigned>(index::SymbolRole::Definition))
+        Result.Attributes |=
+            ReferencesResult::Definition | ReferencesResult::Declaration;
       Results.References.push_back(std::move(Result));
     }
     if (Index && Results.References.size() <= Limit) {
       Req.IDs = std::move(Overrides);
       for (const Decl *D : Decls) {
         // Not all symbols can be referenced from outside (e.g.
         // function-locals).
         // TODO: we could skip TU-scoped symbols here (e.g. static functions) if
if (!Req.IDs.empty() && Index && Results.References.size() <= Limit) {
     Results.HasMore |= Index->refs(Req, [&](const Ref &R) {
       // No need to continue process if we reach the limit.
       if (Results.References.size() > Limit)
         return;
       auto LSPLoc = toLSPLocation(R.Location, *MainFilePath);
       // Avoid indexed results for the main file - the AST is authoritative.
       if (!LSPLoc || LSPLoc->uri.file() == *MainFilePath)
         return;
-
-      Results.References.push_back(std::move(*LSPLoc));
+      ReferencesResult::Reference Result;
+      Result.Loc = std::move(*LSPLoc);
+      if ((R.Kind & RefKind::Declaration) == RefKind::Declaration)
+        Result.Attributes |= ReferencesResult::Declaration;
+      // FIXME: our index should definitely store def | decl separately!
+      if ((R.Kind & RefKind::Definition) == RefKind::Definition)
+        Result.Attributes |=
+            ReferencesResult::Declaration | ReferencesResult::Definition;
+      Results.References.push_back(std::move(Result));
     });
   }
   if (Results.References.size() > Limit) {
     Results.HasMore = true;
     Results.References.resize(Limit);
   }
   return Results;
 }

 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const LocatedSymbol &S) {
   OS << S.Name << ": " << S.PreferredDeclaration;
   if (S.Definition)
     OS << " def=" << *S.Definition;
   return OS;
 }
 
+llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
+                              const ReferencesResult::Reference &R) {
+  OS << R.Loc;
+  if (R.Attributes & ReferencesResult::Declaration)
+    OS << " [decl]";
+  if (R.Attributes & ReferencesResult::Definition)
+    OS << " [def]";
+  return OS;
+}
+
 template <typename HierarchyItem>
 static llvm::Optional<HierarchyItem> declToHierarchyItem(const NamedDecl &ND) {
   ASTContext &Ctx = ND.getASTContext();
   auto &SM = Ctx.getSourceManager();
   SourceLocation NameLoc = nameLocation(ND, Ctx.getSourceManager());
   SourceLocation BeginLoc = SM.getSpellingLoc(SM.getFileLoc(ND.getBeginLoc()));
   SourceLocation EndLoc = SM.getSpellingLoc(SM.getFileLoc(ND.getEndLoc()));
   const auto DeclRange =

clang-tools-extra/clangd/test/references.test

 # RUN: clangd -lit-test < %s | FileCheck -strict-whitespace %s
 {"jsonrpc":"2.0","id":0,"method":"initialize","params":{"processId":123,"rootPath":"clangd","capabilities":{},"trace":"off"}}
 ---
-{"jsonrpc":"2.0","method":"textDocument/didOpen","params":{"textDocument":{"uri":"test:///main.cpp","languageId":"cpp","version":1,"text":"int x; int y = x;"}}}
+{"jsonrpc":"2.0","method":"textDocument/didOpen","params":{"textDocument":{
+  "uri":"test:///main.cpp",
+  "languageId":"cpp",
+  "version":1,
+  "text":"int x; int y = x;"
+}}}
 ---
-{"jsonrpc":"2.0","id":1,"method":"textDocument/references","params":{"textDocument":{"uri":"test:///main.cpp"},"position":{"line":0,"character":4}}}
+{"jsonrpc":"2.0","id":1,"method":"textDocument/references","params":{
+  "textDocument":{"uri":"test:///main.cpp"},
+  "position":{"line":0,"character":4},
+  "context":{"includeDeclaration": false}
+}}
 #      CHECK:  "id": 1
 # CHECK-NEXT:  "jsonrpc": "2.0",
 # CHECK-NEXT:  "result": [
 # CHECK-NEXT:    {
 # CHECK-NEXT:      "range": {
 # CHECK-NEXT:        "end": {
-# CHECK-NEXT:          "character": 5,
-# CHECK-NEXT:          "line": 0
-# CHECK-NEXT:        },
-# CHECK-NEXT:        "start": {
-# CHECK-NEXT:          "character": 4,
-# CHECK-NEXT:          "line": 0
-# CHECK-NEXT:        }
-# CHECK-NEXT:      },
-# CHECK-NEXT:      "uri": "{{.*}}/main.cpp"
-# CHECK-NEXT:    },
-# CHECK-NEXT:    {
-# CHECK-NEXT:      "range": {
-# CHECK-NEXT:        "end": {
 # CHECK-NEXT:          "character": 16,
 # CHECK-NEXT:          "line": 0
 # CHECK-NEXT:        },
 # CHECK-NEXT:        "start": {
 # CHECK-NEXT:          "character": 15,
 # CHECK-NEXT:          "line": 0
 # CHECK-NEXT:        }
 # CHECK-NEXT:      },
 # CHECK-NEXT:      "uri": "{{.*}}/main.cpp"
 # CHECK-NEXT:    }
 # CHECK-NEXT:  ]
 ---
 {"jsonrpc":"2.0","id":3,"method":"shutdown"}
 ---
 {"jsonrpc":"2.0","method":"exit"}

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

TEST(PreamblePatchTest, LocateMacroAtDeletion) {
     ASSERT_TRUE(AST);
 
     auto HI = getHover(*AST, Modified.point(), format::getLLVMStyle(), nullptr);
     ASSERT_TRUE(HI);
     EXPECT_THAT(HI->Definition, "#define BAR");
   }
 }
 
+MATCHER_P(referenceRangeIs, R, "") { return arg.Loc.range == R; }
+
 TEST(PreamblePatchTest, RefsToMacros) {
   struct {
     const char *const Baseline;
     const char *const Modified;
   } Cases[] = {
       // Newly added
       {
           "",
TEST(PreamblePatchTest, RefsToMacros) {
   };
 
   for (const auto &Case : Cases) {
     Annotations Modified(Case.Modified);
     auto AST = createPatchedAST("", Modified.code());
     ASSERT_TRUE(AST);
 
     const auto &SM = AST->getSourceManager();
-    std::vector<Matcher<Location>> ExpectedLocations;
+    std::vector<Matcher<ReferencesResult::Reference>> ExpectedLocations;
     for (const auto &R : Modified.ranges())
-      ExpectedLocations.push_back(Field(&Location::range, R));
+      ExpectedLocations.push_back(referenceRangeIs(R));
 
     for (const auto &P : Modified.points()) {
       auto *MacroTok = AST->getTokens().spelledTokenAt(SM.getComposedLoc(
           SM.getMainFileID(),
           llvm::cantFail(positionToOffset(Modified.code(), P))));
       ASSERT_TRUE(MacroTok);
       EXPECT_THAT(findReferences(*AST, P, 0).References,
                   testing::ElementsAreArray(ExpectedLocations));

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

 #include "gtest/gtest.h"
 #include <string>
 #include <vector>
 
 namespace clang {
 namespace clangd {
 namespace {
 
+using ::testing::AllOf;
 using ::testing::ElementsAre;
 using ::testing::Eq;
 using ::testing::IsEmpty;
 using ::testing::Matcher;
 using ::testing::UnorderedElementsAre;
 using ::testing::UnorderedElementsAreArray;
 using ::testing::UnorderedPointwise;
 
if (arg.Definition->range != *Def) {
     *result_listener << "Definition is " << llvm::to_string(arg.Definition);
     return false;
   }
   return true;
 }
 
 MATCHER_P(Sym, Name, "") { return arg.Name == Name; }
 
-MATCHER_P(RangeIs, R, "") { return arg.range == R; }
+MATCHER_P(RangeIs, R, "") { return arg.Loc.range == R; }
+MATCHER_P(AttrsAre, A, "") { return arg.Attributes == A; }
 
 TEST(LocateSymbol, WithIndex) {
   Annotations SymbolHeader(R"cpp(
         class $forward[[Forward]];
         class $foo[[Foo]] {};
 
         void $f1[[f1]]();
 
TEST(FindImplementations, CaptureDefintion) {
   auto AST = TU.build();
   EXPECT_THAT(
       findImplementations(AST, Code.point(), TU.index().get()),
       UnorderedElementsAre(Sym("Foo", Code.range("Decl"), Code.range("Def")),
                            Sym("Foo", Code.range("Child2"), llvm::None)))
       << Test;
 }
 
+void checkFindRefs(llvm::StringRef Test, bool UseIndex = false) {
+  Annotations T(Test);
+  auto TU = TestTU::withCode(T.code());
+  auto AST = TU.build();
+  std::vector<Matcher<ReferencesResult::Reference>> ExpectedLocations;
+  for (const auto &R : T.ranges())
+    ExpectedLocations.push_back(AllOf(RangeIs(R), AttrsAre(0u)));
+  // $def is actually shorthand for both definition and declaration.
+  // If we have cases that are definition-only, we should change this.
+  for (const auto &R : T.ranges("def"))
+    ExpectedLocations.push_back(
+        AllOf(RangeIs(R), AttrsAre(ReferencesResult::Definition |
+                                   ReferencesResult::Declaration)));
+  for (const auto &R : T.ranges("decl"))
+    ExpectedLocations.push_back(
+        AllOf(RangeIs(R), AttrsAre(ReferencesResult::Declaration)));
+  EXPECT_THAT(
+      findReferences(AST, T.point(), 0, UseIndex ? TU.index().get() : nullptr)
+          .References,
+      UnorderedElementsAreArray(ExpectedLocations))
+      << Test;
+}
+
 TEST(FindReferences, WithinAST) {
   const char *Tests[] = {
       R"cpp(// Local variable
         int main() {
-          int [[foo]];
+          int $def[[foo]];
           [[^foo]] = 2;
           int test1 = [[foo]];
         }
       )cpp",
 
       R"cpp(// Struct
         namespace ns1 {
-        struct [[Foo]] {};
+        struct $def[[Foo]] {};
         } // namespace ns1
         int main() {
           ns1::[[Fo^o]]* Params;
         }
       )cpp",
 
       R"cpp(// Forward declaration
-        class [[Foo]];
-        class [[Foo]] {};
+        class $decl[[Foo]];
+        class $def[[Foo]] {};
         int main() {
           [[Fo^o]] foo;
         }
       )cpp",
 
       R"cpp(// Function
-        int [[foo]](int) {}
+        int $def[[foo]](int) {}
         int main() {
           auto *X = &[[^foo]];
           [[foo]](42);
         }
       )cpp",
 
       R"cpp(// Field
         struct Foo {
-          int [[foo]];
+          int $def[[foo]];
           Foo() : [[foo]](0) {}
         };
         int main() {
           Foo f;
           f.[[f^oo]] = 1;
         }
       )cpp",
 
       R"cpp(// Method call
-        struct Foo { int [[foo]](); };
-        int Foo::[[foo]]() {}
+        struct Foo { int $decl[[foo]](); };
+        int Foo::$def[[foo]]() {}
         int main() {
           Foo f;
           f.[[^foo]]();
         }
       )cpp",
 
       R"cpp(// Constructor
         struct Foo {
-          [[F^oo]](int);
+          $decl[[F^oo]](int);
         };
         void foo() {
           Foo f = [[Foo]](42);
         }
       )cpp",
 
       R"cpp(// Typedef
-        typedef int [[Foo]];
+        typedef int $def[[Foo]];
         int main() {
           [[^Foo]] bar;
         }
       )cpp",
 
       R"cpp(// Namespace
-        namespace [[ns]] {
+        namespace $decl[[ns]] { // FIXME: def?
         struct Foo {};
         } // namespace ns
         int main() { [[^ns]]::Foo foo; }
       )cpp",
 
       R"cpp(// Macros
         #define TYPE(X) X
         #define FOO Foo
         #define CAT(X, Y) X##Y
-        class [[Fo^o]] {};
+        class $def[[Fo^o]] {};
         void test() {
           TYPE([[Foo]]) foo;
           [[FOO]] foo2;
           TYPE(TYPE([[Foo]])) foo3;
           [[CAT]](Fo, o) foo4;
         }
       )cpp",
 
       R"cpp(// Macros
-        #define [[MA^CRO]](X) (X+1)
+        #define $def[[MA^CRO]](X) (X+1)
         void test() {
           int x = [[MACRO]]([[MACRO]](1));
         }
       )cpp",
 
       R"cpp(// Macro outside preamble
         int breakPreamble;
-        #define [[MA^CRO]](X) (X+1)
+        #define $def[[MA^CRO]](X) (X+1)
         void test() {
           int x = [[MACRO]]([[MACRO]](1));
         }
       )cpp",
 
       R"cpp(
-        int [[v^ar]] = 0;
+        int $def[[v^ar]] = 0;
         void foo(int s = [[var]]);
       )cpp",
 
       R"cpp(
        template <typename T>
-       class [[Fo^o]] {};
+       class $def[[Fo^o]] {};
        void func([[Foo]]<int>);
       )cpp",
 
       R"cpp(
        template <typename T>
-       class [[Foo]] {};
+       class $def[[Foo]] {};
        void func([[Fo^o]]<int>);
       )cpp",
       R"cpp(// Not touching any identifiers.
         struct Foo {
-          [[~]]Foo() {};
+          $def[[~]]Foo() {};
         };
         void foo() {
           Foo f;
           f.[[^~]]Foo();
         }
       )cpp",
       R"cpp(// Lambda capture initializer
         void foo() {
-          int [[w^aldo]] = 42;
+          int $def[[w^aldo]] = 42;
           auto lambda = [x = [[waldo]]](){};
         }
       )cpp",
       R"cpp(// Renaming alias
         template <typename> class Vector {};
-        using [[^X]] = Vector<int>;
+        using $def[[^X]] = Vector<int>;
         [[X]] x1;
         Vector<int> x2;
         Vector<double> y;
       )cpp",
   };
-  for (const char *Test : Tests) {
-    Annotations T(Test);
-    auto AST = TestTU::withCode(T.code()).build();
-    std::vector<Matcher<Location>> ExpectedLocations;
-    for (const auto &R : T.ranges())
-      ExpectedLocations.push_back(RangeIs(R));
-    EXPECT_THAT(findReferences(AST, T.point(), 0).References,
-                ElementsAreArray(ExpectedLocations))
-        << Test;
-  }
+  for (const char *Test : Tests)
+    checkFindRefs(Test);
 }
 
 TEST(FindReferences, IncludeOverrides) {
   llvm::StringRef Test =
       R"cpp(
         class Base {
         public:
-          virtual void [[f^unc]]() = 0;
+          virtual void $decl[[f^unc]]() = 0;
         };
         class Derived : public Base {
         public:
-          void [[func]]() override;
+          void $decl[[func]]() override; // FIXME: ref, not decl
         };
         void test(Derived* D) {
           D->[[func]]();
         })cpp";
-  Annotations T(Test);
-  auto TU = TestTU::withCode(T.code());
-  auto AST = TU.build();
-  std::vector<Matcher<Location>> ExpectedLocations;
-  for (const auto &R : T.ranges())
-    ExpectedLocations.push_back(RangeIs(R));
-  EXPECT_THAT(findReferences(AST, T.point(), 0, TU.index().get()).References,
-              ElementsAreArray(ExpectedLocations))
-      << Test;
+  checkFindRefs(Test, /*UseIndex=*/true);
 }
 
 TEST(FindReferences, MainFileReferencesOnly) {
   llvm::StringRef Test =
       R"cpp(
         void test() {
           int [[fo^o]] = 1;
           // refs not from main file should not be included.
           #include "foo.inc"
         })cpp";
 
   Annotations Code(Test);
   auto TU = TestTU::withCode(Code.code());
   TU.AdditionalFiles["foo.inc"] = R"cpp(
       foo = 3;
     )cpp";
   auto AST = TU.build();
 
-  std::vector<Matcher<Location>> ExpectedLocations;
+  std::vector<Matcher<ReferencesResult::Reference>> ExpectedLocations;
   for (const auto &R : Code.ranges())
     ExpectedLocations.push_back(RangeIs(R));
   EXPECT_THAT(findReferences(AST, Code.point(), 0).References,
               ElementsAreArray(ExpectedLocations))
       << Test;
 }
 
 TEST(FindReferences, ExplicitSymbols) {
   const char *Tests[] = {
       R"cpp(
-      struct Foo { Foo* [[self]]() const; };
+      struct Foo { Foo* $decl[[self]]() const; };
       void f() {
         Foo foo;
         if (Foo* T = foo.[[^self]]()) {} // Foo member call expr.
       }
       )cpp",
 
       R"cpp(
       struct Foo { Foo(int); };
       Foo f() {
-        int [[b]];
+        int $def[[b]];
         return [[^b]]; // Foo constructor expr.
       }
       )cpp",
 
       R"cpp(
       struct Foo {};
       void g(Foo);
-      Foo [[f]]();
+      Foo $decl[[f]]();
       void call() {
         g([[^f]]());  // Foo constructor expr.
       }
       )cpp",
 
       R"cpp(
-      void [[foo]](int);
-      void [[foo]](double);
+      void $decl[[foo]](int);
+      void $decl[[foo]](double);
 
       namespace ns {
-      using ::[[fo^o]];
+      using ::$decl[[fo^o]];
       }
       )cpp",
 
       R"cpp(
       struct X {
         operator bool();
       };
 
       int test() {
-        X [[a]];
+        X $def[[a]];
         [[a]].operator bool();
         if ([[a^]]) {} // ignore implicit conversion-operator AST node
       }
     )cpp",
   };
-  for (const char *Test : Tests) {
-    Annotations T(Test);
-    auto AST = TestTU::withCode(T.code()).build();
-    std::vector<Matcher<Location>> ExpectedLocations;
-    for (const auto &R : T.ranges())
-      ExpectedLocations.push_back(RangeIs(R));
-    ASSERT_THAT(ExpectedLocations, Not(IsEmpty()));
-    EXPECT_THAT(findReferences(AST, T.point(), 0).References,
-                ElementsAreArray(ExpectedLocations))
-        << Test;
-  }
+  for (const char *Test : Tests)
+    checkFindRefs(Test);
 }
 
 TEST(FindReferences, NeedsIndexForSymbols) {
   const char *Header = "int foo();";
   Annotations Main("int main() { [[f^oo]](); }");
   TestTU TU;
   TU.Code = std::string(Main.code());
   TU.HeaderCode = Header;
   auto AST = TU.build();
 
   // References in main file are returned without index.
   EXPECT_THAT(
       findReferences(AST, Main.point(), 0, /*Index=*/nullptr).References,
       ElementsAre(RangeIs(Main.range())));
   Annotations IndexedMain(R"cpp(
-    int main() { [[f^oo]](); }
+    int [[foo]]() { return 42; }
   )cpp");
 
   // References from indexed files are included.
   TestTU IndexedTU;
   IndexedTU.Code = std::string(IndexedMain.code());
   IndexedTU.Filename = "Indexed.cpp";
   IndexedTU.HeaderCode = Header;
   EXPECT_THAT(
       findReferences(AST, Main.point(), 0, IndexedTU.index().get()).References,
-      ElementsAre(RangeIs(Main.range()), RangeIs(IndexedMain.range())));
+      ElementsAre(RangeIs(Main.range()),
+                  AllOf(RangeIs(IndexedMain.range()),
+                        AttrsAre(ReferencesResult::Declaration |
+                                 ReferencesResult::Definition))));
   auto LimitRefs =
       findReferences(AST, Main.point(), /*Limit*/ 1, IndexedTU.index().get());
   EXPECT_EQ(1u, LimitRefs.References.size());
   EXPECT_TRUE(LimitRefs.HasMore);
 
   // Avoid indexed results for the main file. Use AST for the mainfile.
   TU.Code = ("\n\n" + Main.code()).str();
   EXPECT_THAT(findReferences(AST, Main.point(), 0, TU.index().get()).References,