[clangd] Add decl/def support to SymbolDetails

[dgoldman]

Summary

Add an optional declarationRange and definitionRange to SymbolDetails.

This will allow SourceKit-LSP to implement toggling between goto
definition/declaration based on whether the symbol at the cursor
is a definition or declaration.

In addition, make some minor fixes for ObjCMethodDecl:

• XRefs.cpp getDefinition now sees ObjC method defs but I've left a TODO to implement proper searching for impls from a decl
• nameLocation for ObjC methods should point to foo in - (void)foo, not the -

[dgoldman]

Revert unintended change in symbol-info.test

[dgoldman]

For more context see the discussion on b/187405187

[kadircet]

thanks, this LG per symboldetails change but as discussed offline i think we actually need a new request or a capability to indicate this (and having a new request is just easier for both clients and clangd) otherwise it can't be reliably used by clients.

in addition to that let's move the objcmethod related changes to its own patch since it's addressing a different issue.

clang-tools-extra/clangd/AST.cpp

174

can we do this in a separate change? as it has wider implications

clang-tools-extra/clangd/Protocol.h

1097

ah getting absolute paths .. alright i guess we need to make this one optional, sorry for the noise on this one :/

clang-tools-extra/clangd/XRefs.cpp

86

again let's move this into a separate change

1528–1529

let's just pass the TUPath from ClangdServer into the request. (we should do the same for locateSymbolAt, but on a separate change)

1557

let's do this cannonicalization in the beginning of the loop, i.e:

for (const NamedDecl *D : getDeclAtPosition(AST, *CurLoc, Relations)) {
  D = getPreferredDecl(D);
  ....
}

clang-tools-extra/clangd/test/symbol-info.test

4

can you also introduce the definition?

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

24

nit: drop the empty lines in between these fields

29

since you're always calling these decl or def, you can instead check whether the annotation has any range named def/decl and expect those accordingly rather than mentioning them one extra time inside the testcases. i.e:

case:

void $def[[foo]]() {}
          int bar() {
            fo^o();
          }

check:

Annotations Test(Case);
SymbolDetails Expected;
auto Def = Test.ranges("def");
auto Decl = Test.ranges("decl");
if (!Def.empty()) {
  Expected.decl = Expected.def = makelocation ...
} else if (!Decl.empty()) {
  Expected.decl = makelocation ...
}

[dgoldman]

clang-tools-extra/clangd/AST.cpp

174

Sent out https://reviews.llvm.org/D130095, will rebase this on top once that's submitted.

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

29

Thanks, although that won't work for the // Multiple symbols returned - using overloaded function name test case. Should I move that one out to to be handled separately?

[sammccall]

clang-tools-extra/clangd/XRefs.cpp

1528–1529

driveby: @kadircet any reason not to store the TUPath on ParsedAST? We already pass it to ParsedAST::build()

[dgoldman]

Minor fixes for review (some still pending based on discussion)

clang-tools-extra/clangd/XRefs.cpp

1528–1529

I think this would simplify things quite a bit - otherwise I also need to update the DumpSymbol tweak to store/compute the TUPath (or just provide an empty one). LMK what I should do.

[dgoldman]

Run clang-format

[dgoldman]

clang-tools-extra/clangd/XRefs.cpp

1528–1529

Also, not sure how this would affect the Windows failure, which currently fails since the decl/definition locations reference "file:///C:/clangd-test/simple.cpp" instead of "test:///simple.cpp"... could add a regex or limit the test to non-Windows as a work around though. "textDocument/publishDiagnostics" also seems to reference that absolute path as well instead of the test:// URI

[kadircet]

clang-tools-extra/clangd/XRefs.cpp

1528–1529

sent out D130690 for preserving TUPath in ParsedAST.

as for matching output in lit tests, clangd always outputs file uris. so you should rather match with a regex (unless testing something platform-specific).
you can use # CHECK-NEXT: "uri": "file://{{.*}}/clangd-test/simple.cpp" instead to match output.

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

29

ah sorry i missed those, nvm this one. no need for splitting those out.

[dgoldman]

Fix broken test and swap to AST.tuPath()

[dgoldman]

Run clang-format

[dgoldman]

Ah my bad didn't realize you hadn't accepted this, was there anything else you wanted me to change?

[kadircet]

no worries, as discussed offline this LG

clang-tools-extra/clangd/AST.cpp

 //===--- AST.cpp - Utility AST functions  -----------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "AST.h"
 
 #include "SourceCode.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ASTTypeTraits.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclBase.h"
 #include "clang/AST/DeclCXX.h"
+#include "clang/AST/DeclObjC.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/DeclarationName.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/NestedNameSpecifier.h"
 #include "clang/AST/PrettyPrinter.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/AST/Stmt.h"
 #include "clang/AST/TemplateBase.h"

 
 bool isImplementationDetail(const Decl *D) {
   return !isSpelledInSource(D->getLocation(),
                             D->getASTContext().getSourceManager());
 }
 
 SourceLocation nameLocation(const clang::Decl &D, const SourceManager &SM) {
   auto L = D.getLocation();
+  // Use the start of the first selector fragment instead of the -/+ location.
+  if (const auto *MD = dyn_cast<ObjCMethodDecl>(&D))
+    L = MD->getSelectorStartLoc();
   if (isSpelledInSource(L, SM))
     return SM.getSpellingLoc(L);
   return SM.getExpansionLoc(L);
 }
 
 std::string printQualifiedName(const NamedDecl &ND) {
   std::string QName;
   llvm::raw_string_ostream OS(QName);

clang-tools-extra/clangd/Protocol.h

struct SymbolDetails {
   /// Unified Symbol Resolution identifier
   /// This is an opaque string uniquely identifying a symbol.
   /// Unlike SymbolID, it is variable-length and somewhat human-readable.
   /// It is a common representation across several clang tools.
   /// (See USRGeneration.h)
   std::string USR;
 
   SymbolID ID;
+
+  llvm::Optional<Location> declarationRange;
+
+  llvm::Optional<Location> definitionRange;
 };
 llvm::json::Value toJSON(const SymbolDetails &);
 llvm::raw_ostream &operator<<(llvm::raw_ostream &, const SymbolDetails &);
 bool operator==(const SymbolDetails &, const SymbolDetails &);
 
 /// The parameters of a Workspace Symbol Request.
 struct WorkspaceSymbolParams {
   /// A query string to filter symbols by.

clang-tools-extra/clangd/Protocol.cpp

 llvm::raw_ostream &operator<<(llvm::raw_ostream &O,
                               const SymbolInformation &SI) {
   O << SI.containerName << "::" << SI.name << " - " << toJSON(SI);
   return O;
 }
 
 bool operator==(const SymbolDetails &LHS, const SymbolDetails &RHS) {
   return LHS.name == RHS.name && LHS.containerName == RHS.containerName &&
-         LHS.USR == RHS.USR && LHS.ID == RHS.ID;
+         LHS.USR == RHS.USR && LHS.ID == RHS.ID &&
+         LHS.declarationRange == RHS.declarationRange &&
+         LHS.definitionRange == RHS.definitionRange;
 }
 
 llvm::json::Value toJSON(const SymbolDetails &P) {
   llvm::json::Object Result{{"name", llvm::json::Value(nullptr)},
                             {"containerName", llvm::json::Value(nullptr)},
                             {"usr", llvm::json::Value(nullptr)},
                             {"id", llvm::json::Value(nullptr)}};
 
   if (!P.name.empty())
     Result["name"] = P.name;
 
   if (!P.containerName.empty())
     Result["containerName"] = P.containerName;
 
   if (!P.USR.empty())
     Result["usr"] = P.USR;
 
   if (P.ID)
     Result["id"] = P.ID.str();
 
+  if (P.declarationRange)
+    Result["declarationRange"] = *P.declarationRange;
+
+  if (P.definitionRange)
+    Result["definitionRange"] = *P.definitionRange;
+
   // FIXME: workaround for older gcc/clang
   return std::move(Result);
 }
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &O, const SymbolDetails &S) {
   if (!S.containerName.empty()) {
     O << S.containerName;
     llvm::StringRef ContNameRef;

clang-tools-extra/clangd/XRefs.cpp

if (const auto *TD = dyn_cast<TagDecl>(D))
     return TD->getDefinition();
   if (const auto *VD = dyn_cast<VarDecl>(D))
     return VD->getDefinition();
   if (const auto *FD = dyn_cast<FunctionDecl>(D))
     return FD->getDefinition();
   if (const auto *CTD = dyn_cast<ClassTemplateDecl>(D))
     if (const auto *RD = CTD->getTemplatedDecl())
       return RD->getDefinition();
+  if (const auto *MD = dyn_cast<ObjCMethodDecl>(D))
+    if (MD->isThisDeclarationADefinition())
+      return MD;
+    // FIXME: We need to search impl objc containers like
+    // ObjCMethodDecl::getNextRedeclarationImpl().
+
   // Objective-C classes can have three types of declarations:
   //
   // - forward declaration: @class MyClass;
   // - true declaration (interface definition): @interface MyClass ... @end
   // - true definition (implementation): @implementation MyClass ... @end
   //
   // Objective-C categories are extensions are on classes:
   //

 
 std::vector<SymbolDetails> getSymbolInfo(ParsedAST &AST, Position Pos) {
   const SourceManager &SM = AST.getSourceManager();
   auto CurLoc = sourceLocationInMainFile(SM, Pos);
   if (!CurLoc) {
     llvm::consumeError(CurLoc.takeError());
     return {};
   }
-
+  auto MainFilePath =
+      getCanonicalPath(SM.getFileEntryForID(SM.getMainFileID()), SM);
   std::vector<SymbolDetails> Results;
 
   // We also want the targets of using-decls, so we include
   // DeclRelation::Underlying.
   DeclRelationSet Relations = DeclRelation::TemplatePattern |
                               DeclRelation::Alias | DeclRelation::Underlying;
   for (const NamedDecl *D : getDeclAtPosition(AST, *CurLoc, Relations)) {
     SymbolDetails NewSymbol;
     std::string QName = printQualifiedName(*D);
     auto SplitQName = splitQualifiedName(QName);
     NewSymbol.containerName = std::string(SplitQName.first);
     NewSymbol.name = std::string(SplitQName.second);
 
     if (NewSymbol.containerName.empty()) {
       if (const auto *ParentND =
               dyn_cast_or_null<NamedDecl>(D->getDeclContext()))
         NewSymbol.containerName = printQualifiedName(*ParentND);
     }
     llvm::SmallString<32> USR;
     if (!index::generateUSRForDecl(D, USR)) {
       NewSymbol.USR = std::string(USR.str());
       NewSymbol.ID = SymbolID(NewSymbol.USR);
     }
+    if (MainFilePath) {
+      if (const NamedDecl *Def = getDefinition(D))
+        NewSymbol.definitionRange = makeLocation(
+            AST.getASTContext(), nameLocation(*Def, SM), *MainFilePath);
+      const NamedDecl *Decl = getPreferredDecl(D);
+      NewSymbol.declarationRange = makeLocation(
+          AST.getASTContext(), nameLocation(*Decl, SM), *MainFilePath);
+    }
+
     Results.push_back(std::move(NewSymbol));
   }
 
   const auto *IdentifierAtCursor =
       syntax::spelledIdentifierTouching(*CurLoc, AST.getTokens());
   if (!IdentifierAtCursor)
     return Results;
 

clang-tools-extra/clangd/test/symbol-info.test

-# RUN: clangd -lit-test < %s | FileCheck %s
+# RUN: clangd -lit-test < %s | FileCheck %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:///simple.cpp","languageId":"cpp","version":1,"text":"void foo(); int main() { foo(); }\n"}}}
 ---
 {"jsonrpc":"2.0","id":1,"method":"textDocument/symbolInfo","params":{"textDocument":{"uri":"test:///simple.cpp"},"position":{"line":0,"character":27}}}
 #      CHECK:    "containerName": null,
+# CHECK-NEXT:    "declarationRange": {
+# CHECK-NEXT:      "range": {
+# CHECK-NEXT:        "end": {
+# CHECK-NEXT:          "character": 8,
+# CHECK-NEXT:          "line": 0
+# CHECK-NEXT:        },
+# CHECK-NEXT:        "start": {
+# CHECK-NEXT:         "character": 5,
+# CHECK-NEXT:         "line": 0
+# CHECK-NEXT:      }
+# CHECK-NEXT:      },
+# CHECK-NEXT:      "uri": "file:///clangd-test/simple.cpp"
+# CHECK-NEXT:    },
 # CHECK-NEXT:    "id": "CA2EBE44A1D76D2A",
 # CHECK-NEXT:    "name": "foo",
 # CHECK-NEXT:    "usr": "c:@F@foo#"
 ---
 {"jsonrpc":"2.0","id":3,"method":"shutdown"}
 ---
 {"jsonrpc":"2.0","method":"exit"}

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

 #include "gtest/gtest.h"
 
 namespace clang {
 namespace clangd {
 namespace {
 
 using ::testing::UnorderedElementsAreArray;
 
-auto CreateExpectedSymbolDetails = [](const std::string &Name,
-                                      const std::string &Container,
-                                      const std::string &USR) {
-  return SymbolDetails{Name, Container, USR, SymbolID(USR)};
+// Partial SymbolDetails with the rest filled in at testing time.
+struct ExpectedSymbolDetails {
+  std::string Name;
+
+  std::string Container;
+
+  std::string USR;
+
+  const char *DeclMarker = nullptr;
+  const char *DefMarker = nullptr;
 };
 
 TEST(SymbolInfoTests, All) {
-  std::pair<const char *, std::vector<SymbolDetails>>
+  std::pair<const char *, std::vector<ExpectedSymbolDetails>>
       TestInputExpectedOutput[] = {
           {
               R"cpp( // Simple function reference - declaration
-          void foo();
+          void $decl[[foo]]();
           int bar() {
             fo^o();
           }
         )cpp",
-              {CreateExpectedSymbolDetails("foo", "", "c:@F@foo#")}},
+              {ExpectedSymbolDetails{"foo", "", "c:@F@foo#", "decl"}}},
           {
               R"cpp( // Simple function reference - definition
-          void foo() {}
+          void $def[[foo]]() {}
+          int bar() {
+            fo^o();
+          }
+        )cpp",
+              {ExpectedSymbolDetails{"foo", "", "c:@F@foo#", "def", "def"}}},
+          {
+              R"cpp( // Simple function reference - decl and def
+          void $decl[[foo]]();
+          void $def[[foo]]() {}
           int bar() {
             fo^o();
           }
         )cpp",
-              {CreateExpectedSymbolDetails("foo", "", "c:@F@foo#")}},
+              {ExpectedSymbolDetails{"foo", "", "c:@F@foo#", "decl", "def"}}},
+          {
+              R"cpp( // Simple class reference - decl and def
+          @interface $decl[[Foo]]
+          @end
+          @implementation $def[[Foo]]
+          @end
+          void doSomething(F^oo *obj) {}
+        )cpp",
+              {ExpectedSymbolDetails{"Foo", "", "c:objc(cs)Foo", "decl", "def"}}},
+          {
+              R"cpp( // Simple method reference - decl and def
+          @interface Foo
+          - (void)$decl[[foo]];
+          @end
+          @implementation Foo
+          - (void)$def[[fo^o]] {}
+          @end
+        )cpp",
+              {ExpectedSymbolDetails{"foo", "Foo::", "c:objc(cs)Foo(im)foo", "decl", "def"}}},
           {
               R"cpp( // Function in namespace reference
           namespace bar {
-            void foo();
+            void $decl[[foo]]();
             int baz() {
               fo^o();
             }
           }
         )cpp",
-              {CreateExpectedSymbolDetails("foo", "bar::", "c:@N@bar@F@foo#")}},
+              {ExpectedSymbolDetails{"foo", "bar::", "c:@N@bar@F@foo#", "decl"}}},
           {
               R"cpp( // Function in different namespace reference
           namespace bar {
-            void foo();
+            void $decl[[foo]]();
           }
           namespace barbar {
             int baz() {
               bar::fo^o();
             }
           }
         )cpp",
-              {CreateExpectedSymbolDetails("foo", "bar::", "c:@N@bar@F@foo#")}},
+              {ExpectedSymbolDetails{"foo", "bar::", "c:@N@bar@F@foo#", "decl"}}},
           {
               R"cpp( // Function in global namespace reference
-          void foo();
+          void $decl[[foo]]();
           namespace Nbar {
             namespace Nbaz {
               int baz() {
                 ::fo^o();
               }
             }
           }
         )cpp",
-              {CreateExpectedSymbolDetails("foo", "", "c:@F@foo#")}},
+              {ExpectedSymbolDetails{"foo", "", "c:@F@foo#", "decl"}}},
           {
               R"cpp( // Function in anonymous namespace reference
           namespace {
-            void foo();
+            void $decl[[foo]]();
           }
           namespace barbar {
             int baz() {
               fo^o();
             }
           }
         )cpp",
-              {CreateExpectedSymbolDetails("foo", "(anonymous)",
-                                           "c:TestTU.cpp@aN@F@foo#")}},
+              {ExpectedSymbolDetails{"foo", "(anonymous)",
+                                     "c:TestTU.cpp@aN@F@foo#", "decl"}}},
           {
               R"cpp( // Function reference - ADL
           namespace bar {
             struct BarType {};
-            void foo(const BarType&);
+            void $decl[[foo]](const BarType&);
           }
           namespace barbar {
             int baz() {
               bar::BarType b;
               fo^o(b);
             }
           }
         )cpp",
-              {CreateExpectedSymbolDetails(
-                  "foo", "bar::", "c:@N@bar@F@foo#&1$@N@bar@S@BarType#")}},
+              {ExpectedSymbolDetails{
+                  "foo", "bar::", "c:@N@bar@F@foo#&1$@N@bar@S@BarType#", "decl"}}},
           {
               R"cpp( // Global value reference
-          int value;
+          int $def[[value]];
           void foo(int) { }
           void bar() {
             foo(val^ue);
           }
         )cpp",
-              {CreateExpectedSymbolDetails("value", "", "c:@value")}},
+              {ExpectedSymbolDetails{"value", "", "c:@value", "def", "def"}}},
           {
               R"cpp( // Local value reference
-          void foo() { int aaa; int bbb = aa^a; }
+          void foo() { int $def[[aaa]]; int bbb = aa^a; }
         )cpp",
-              {CreateExpectedSymbolDetails("aaa", "foo",
-                                           "c:TestTU.cpp@49@F@foo#@aaa")}},
+              {ExpectedSymbolDetails{"aaa", "foo",
+                                     "c:TestTU.cpp@49@F@foo#@aaa", "def", "def"}}},
           {
               R"cpp( // Function param
-          void bar(int aaa) {
+          void bar(int $def[[aaa]]) {
             int bbb = a^aa;
           }
         )cpp",
-              {CreateExpectedSymbolDetails("aaa", "bar",
-                                           "c:TestTU.cpp@38@F@bar#I#@aaa")}},
+              {ExpectedSymbolDetails{"aaa", "bar",
+                                     "c:TestTU.cpp@38@F@bar#I#@aaa", "def", "def"}}},
           {
               R"cpp( // Lambda capture
           void foo() {
-            int ii;
+            int $def[[ii]];
             auto lam = [ii]() {
               return i^i;
             };
           }
         )cpp",
-              {CreateExpectedSymbolDetails("ii", "foo",
-                                           "c:TestTU.cpp@54@F@foo#@ii")}},
+              {ExpectedSymbolDetails{"ii", "foo",
+                                     "c:TestTU.cpp@54@F@foo#@ii", "def", "def"}}},
           {
               R"cpp( // Macro reference
           #define MACRO 5\nint i = MAC^RO;
         )cpp",
-              {CreateExpectedSymbolDetails("MACRO", "",
-                                           "c:TestTU.cpp@38@macro@MACRO")}},
+              {ExpectedSymbolDetails{"MACRO", "",
+                                           "c:TestTU.cpp@38@macro@MACRO"}}},
           {
               R"cpp( // Macro reference
           #define MACRO 5\nint i = MACRO^;
         )cpp",
-              {CreateExpectedSymbolDetails("MACRO", "",
-                                           "c:TestTU.cpp@38@macro@MACRO")}},
+              {ExpectedSymbolDetails{"MACRO", "",
+                                           "c:TestTU.cpp@38@macro@MACRO"}}},
           {
               R"cpp( // Multiple symbols returned - using overloaded function name
-          void foo() {}
-          void foo(bool) {}
-          void foo(int) {}
+          void $def[[foo]]() {}
+          void $def_bool[[foo]](bool) {}
+          void $def_int[[foo]](int) {}
           namespace bar {
-            using ::fo^o;
+            using ::$decl[[fo^o]];
           }
         )cpp",
-              {CreateExpectedSymbolDetails("foo", "", "c:@F@foo#"),
-               CreateExpectedSymbolDetails("foo", "", "c:@F@foo#b#"),
-               CreateExpectedSymbolDetails("foo", "", "c:@F@foo#I#"),
-               CreateExpectedSymbolDetails("foo", "bar::", "c:@N@bar@UD@foo")}},
+              {ExpectedSymbolDetails{"foo", "", "c:@F@foo#", "def", "def"},
+               ExpectedSymbolDetails{"foo", "", "c:@F@foo#b#", "def_bool", "def_bool"},
+               ExpectedSymbolDetails{"foo", "", "c:@F@foo#I#", "def_int", "def_int"},
+               ExpectedSymbolDetails{"foo", "bar::", "c:@N@bar@UD@foo", "decl"}}},
           {
               R"cpp( // Multiple symbols returned - implicit conversion
           struct foo {};
           struct bar {
             bar(const foo&) {}
           };
           void func_baz1(bar) {}
           void func_baz2() {
-            foo ff;
+            foo $def[[ff]];
             func_baz1(f^f);
           }
         )cpp",
-              {CreateExpectedSymbolDetails(
-                  "ff", "func_baz2", "c:TestTU.cpp@218@F@func_baz2#@ff")}},
+              {ExpectedSymbolDetails{
+                  "ff", "func_baz2", "c:TestTU.cpp@218@F@func_baz2#@ff", "def", "def"}}},
           {
               R"cpp( // Type reference - declaration
-          struct foo;
+          struct $decl[[foo]];
           void bar(fo^o*);
         )cpp",
-              {CreateExpectedSymbolDetails("foo", "", "c:@S@foo")}},
+              {ExpectedSymbolDetails{"foo", "", "c:@S@foo", "decl"}}},
           {
               R"cpp( // Type reference - definition
-          struct foo {};
+          struct $def[[foo]] {};
           void bar(fo^o*);
         )cpp",
-              {CreateExpectedSymbolDetails("foo", "", "c:@S@foo")}},
+              {ExpectedSymbolDetails{"foo", "", "c:@S@foo", "def", "def"}}},
           {
               R"cpp( // Type Reference - template argument
-          struct foo {};
+          struct $def[[foo]] {};
           template<class T> struct bar {};
           void baz() {
             bar<fo^o> b;
           }
         )cpp",
-              {CreateExpectedSymbolDetails("foo", "", "c:@S@foo")}},
+              {ExpectedSymbolDetails{"foo", "", "c:@S@foo", "def", "def"}}},
           {
               R"cpp( // Template parameter reference - type param
-          template<class TT> struct bar {
+          template<class $def[[TT]]> struct bar {
             T^T t;
           };
         )cpp",
-              {CreateExpectedSymbolDetails("TT", "bar::", "c:TestTU.cpp@65")}},
+              {ExpectedSymbolDetails{"TT", "bar::", "c:TestTU.cpp@65", "def", "def"}}},
           {
               R"cpp( // Template parameter reference - type param
-          template<int NN> struct bar {
+          template<int $def[[NN]]> struct bar {
             int a = N^N;
           };
         )cpp",
-              {CreateExpectedSymbolDetails("NN", "bar::", "c:TestTU.cpp@65")}},
+              {ExpectedSymbolDetails{"NN", "bar::", "c:TestTU.cpp@65", "def", "def"}}},
           {
               R"cpp( // Class member reference - objec
           struct foo {
-            int aa;
+            int $def[[aa]];
           };
           void bar() {
             foo f;
             f.a^a;
           }
         )cpp",
-              {CreateExpectedSymbolDetails("aa", "foo::", "c:@S@foo@FI@aa")}},
+              {ExpectedSymbolDetails{"aa", "foo::", "c:@S@foo@FI@aa", "def", "def"}}},
           {
               R"cpp( // Class member reference - pointer
           struct foo {
-            int aa;
+            int $def[[aa]];
           };
           void bar() {
             &foo::a^a;
           }
         )cpp",
-              {CreateExpectedSymbolDetails("aa", "foo::", "c:@S@foo@FI@aa")}},
+              {ExpectedSymbolDetails{"aa", "foo::", "c:@S@foo@FI@aa", "def", "def"}}},
           {
               R"cpp( // Class method reference - objec
           struct foo {
-            void aa() {}
+            void $def[[aa]]() {}
           };
           void bar() {
             foo f;
             f.a^a();
           }
         )cpp",
-              {CreateExpectedSymbolDetails("aa", "foo::", "c:@S@foo@F@aa#")}},
+              {ExpectedSymbolDetails{"aa", "foo::", "c:@S@foo@F@aa#", "def", "def"}}},
           {
               R"cpp( // Class method reference - pointer
           struct foo {
-            void aa() {}
+            void $def[[aa]]() {}
           };
           void bar() {
             &foo::a^a;
           }
         )cpp",
-              {CreateExpectedSymbolDetails("aa", "foo::", "c:@S@foo@F@aa#")}},
+              {ExpectedSymbolDetails{"aa", "foo::", "c:@S@foo@F@aa#", "def", "def"}}},
           {
               R"cpp( // Typedef
-          typedef int foo;
+          typedef int $decl[[foo]];
           void bar() {
             fo^o a;
           }
         )cpp",
-              {CreateExpectedSymbolDetails("foo", "", "c:TestTU.cpp@T@foo")}},
+              {ExpectedSymbolDetails{"foo", "", "c:TestTU.cpp@T@foo", "decl"}}},
           {
               R"cpp( // Type alias
-          using foo = int;
+          using $decl[[foo]] = int;
           void bar() {
             fo^o a;
           }
         )cpp",
-              {CreateExpectedSymbolDetails("foo", "", "c:@foo")}},
+              {ExpectedSymbolDetails{"foo", "", "c:@foo", "decl"}}},
           {
               R"cpp( // Namespace reference
-          namespace foo {}
+          namespace $decl[[foo]] {}
           using namespace fo^o;
         )cpp",
-              {CreateExpectedSymbolDetails("foo", "", "c:@N@foo")}},
+              {ExpectedSymbolDetails{"foo", "", "c:@N@foo", "decl"}}},
           {
               R"cpp( // Enum value reference
-          enum foo { bar, baz };
+          enum foo { $def[[bar]], baz };
           void f() {
             foo fff = ba^r;
           }
         )cpp",
-              {CreateExpectedSymbolDetails("bar", "foo", "c:@E@foo@bar")}},
+              {ExpectedSymbolDetails{"bar", "foo", "c:@E@foo@bar", "def", "def"}}},
           {
               R"cpp( // Enum class value reference
-          enum class foo { bar, baz };
+          enum class foo { $def[[bar]], baz };
           void f() {
             foo fff = foo::ba^r;
           }
         )cpp",
-              {CreateExpectedSymbolDetails("bar", "foo::", "c:@E@foo@bar")}},
+              {ExpectedSymbolDetails{"bar", "foo::", "c:@E@foo@bar", "def", "def"}}},
           {
               R"cpp( // Parameters in declarations
-          void foo(int ba^r);
+          void foo(int $def[[ba^r]]);
         )cpp",
-              {CreateExpectedSymbolDetails("bar", "foo",
-                                           "c:TestTU.cpp@50@F@foo#I#@bar")}},
+              {ExpectedSymbolDetails{"bar", "foo",
+                                     "c:TestTU.cpp@50@F@foo#I#@bar", "def", "def"}}},
           {
               R"cpp( // Type inference with auto keyword
           struct foo {};
           foo getfoo() { return foo{}; }
           void f() {
             au^to a = getfoo();
           }
         )cpp",
               {/* not implemented */}},
           {
               R"cpp( // decltype
           struct foo {};
           void f() {
             foo f;
             declt^ype(f);
           }
         )cpp",
               {/* not implemented */}},
       };
 
   for (const auto &T : TestInputExpectedOutput) {
     Annotations TestInput(T.first);
-    auto AST = TestTU::withCode(TestInput.code()).build();
+    TestTU TU;
+    TU.Code = std::string(TestInput.code());
+    TU.ExtraArgs.push_back("-xobjective-c++");
+    auto AST = TU.build();
+
+    std::vector<SymbolDetails> Expected;
+    for (const auto &Sym : T.second) {
+      llvm::Optional<Location> Decl, Def;
+      if (Sym.DeclMarker)
+        Decl = Location{URIForFile::canonicalize(testPath(TU.Filename), ""), TestInput.range(Sym.DeclMarker)};
+      if (Sym.DefMarker)
+        Def = Location{URIForFile::canonicalize(testPath(TU.Filename), ""), TestInput.range(Sym.DefMarker)};
+      Expected.push_back({Sym.Name, Sym.Container, Sym.USR, SymbolID(Sym.USR), Decl, Def});
+    }
 
     EXPECT_THAT(getSymbolInfo(AST, TestInput.point()),
-                UnorderedElementsAreArray(T.second))
+                UnorderedElementsAreArray(Expected))
         << T.first;
   }
 }
 
 } // namespace
 } // namespace clangd
 } // namespace clang