[clangd] Populate detail field in document symbols

[lightmelodies]

Summary

This commit fix https://github.com/clangd/clangd/issues/520 and https://github.com/clangd/clangd/issues/601.

[sammccall]

Thanks for doing this!

I think this behavior is a great starting point.

I suspect printing the decl is more verbose than desired in a lot of cases, at least avoiding repeating the identifier would be nice. e.g.
x | int x --> x | int
foo | void foo() --> foo | void()
bar | struct bar {} --> bar | struct
This can be tweaked later, the simple implementation seems like a big improvement already.
If you feel like it though, I think this is mostly just printing the type instead of the decl for ValueDecls.

When you upload snapshots, please prepare the diffs with full context -U9999 to make review easier. (the Arcanist arc tool will do this automatically)

clang-tools-extra/clangd/FindSymbols.cpp

201

nit: limit the scope of raw_string_ostream by putting it in an anonymous block.
It does not flush until destroyed (or explicitly flushed)

201

Can we pull out a helper function for this? getSymbolDetail or so?

For now it's just a few lines but I imagine it could grow as we refine the behavior.

clang-tools-extra/clangd/Hover.h

20 ↗

(On Diff #323882)

this isn't a reasonable thing to expose & depend on from FindSymbols.cpp.

It's fine to add a copy into FindSymbols.cpp, especially since you want a slightly different policy anyway

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

1

Can you add unit-tests for this feature in FindSymbolsTests.cpp?
Don't need to assert the detail for every symbol we test there, but adding a WithDetail matcher and adding it to a few nodes in the testcases would be useful. In particular, at least one that shows the getDescribedTemplateParams bit.

(It's nice to have a basic smoke-test here but unit-tests are where we try to cover more of the cases)

[lightmelodies]

Thanks for your response. Yes decl is too verbose in many cases. In fact I have tried another concise version, but I can not decide which one is better. Unit test in FindSymbolsTests.cpp is also done, but I would like upload them after we reach an agreement on what behavior is prefered.

[sammccall]

This looks really good. Only thing i'd really think about changing in behavior is dropping the template params.
Please go ahead and upload the unittests!

(And thanks for including the diff context)

clang-tools-extra/clangd/FindSymbols.cpp

184

As a tradeoff between brevity and information, we might consider printing template but not the param list.

Particularly for functions this is useful, as template params are mostly types repeated in the signature:

- DenseMap | template <typename InputIt> void (const InputIt&, const InputIt&)
+ DenseMap | template void (const InputIt&, const InputIt&)

But I think this may be fine for classes as well:

- DenseMap | template <typename KeyT, typename ValueT, typename KeyInfoT = ...> class
+ DenseMap | template class

188

It might not makes sense to print the placeholder DependentType, types that contain undeduced auto, and maybe some other cases.

(This can definitely be a fixme comment for later - it'll be hard to find exactly the right cases in one pass)

192

What you have here is probably best, just thinking out loud...

we could also consider including the underlying type like = int but I suspect the difference between ValueDecl is too subtle and sometimes the types are really long anyway.

194

(if we drop the template params then I don't think we need to even print "template" in this case because concepts are always templates)

197

nit: either OS.flush(); return Detail; or equivalently return std::move(OS.str());

(Otherwise whether OS's buffer gets flushed into the right string or not is fragile, I believe relying on move elision)

[lightmelodies]

Change behavior of template and add unit tests.

[sammccall]

Nice! This looks good to land as-is, I just have some suggestions where we may want to mark behavior to revisit later, and some places where we could trim the tests a bit.

Do you have commit access, or want me to land this for you? (I'd need an address for the commit)

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

384

the void return type isn't really meaningful

may want a FIXME here that () or constructor() would probably be better

(no need to fix though)

392

for destructors I think we should probably suppress detail entirely - signature is always the same and it's clear from the name it's a destructor.

493

up to you, but we don't need to add WithDetail() assertions everywhere, probably just enough to ensure we cover the interesting cases.

We could leave out these ones, exportContext, noLocals etc that are really testing other things.

580–581

feels like this could benefit from being "specialization struct" or so, "specialization int" below etc.

Again, this is a possible FIXME comment, not something that needs to be done now.

629

(all these WithDetail("")s seem pretty redundant)

[lightmelodies]

Better printing for C++ constructor and destructor. Remove unnecessary test cases.

[lightmelodies]

In D96751#2571346, @sammccall wrote:

Nice! This looks good to land as-is, I just have some suggestions where we may want to mark behavior to revisit later, and some places where we could trim the tests a bit.

Do you have commit access, or want me to land this for you? (I'd need an address for the commit)

I don't have commit access yet, it will be appreciated if you can land this for me (just use lightmelodies([e-mail]))

[sammccall]

Fantastic, thank you!

clang-tools-extra/clangd/FindSymbols.cpp

189

I think equivalent and a little safer is

std::string ConstructorType = VD->getType().getAsString(P);
llvm::StringRef WithoutVoid = ConstructorType;
WithoutVoid.consume_front("void");
OS << WithoutVoid;

(I'll apply this when landing)

[lightmelodies]

In D96751#2571563, @sammccall wrote:

Fantastic, thank you!

Maybe WithoutVoid.consume_front("void ");

[sammccall]

In D96751#2571579, @lightmelodies wrote:

In D96751#2571563, @sammccall wrote:

Fantastic, thank you!

Maybe WithoutVoid.consume_front("void ");

Oh wow, yes... sizeof() was really doing some heavy lifting :-)

clang-tools-extra/clangd/FindSymbols.cpp

Index->fuzzyFind(Req, [HintPath, &Top, &Filter, AnyScope = Req.AnyScope,
     Top.push({Score, std::move(Info)});
   });
   for (auto &R : std::move(Top).items())
     Result.push_back(std::move(R.second));
   return Result;
 }
 
 namespace {
+std::string getSymbolDetail(ASTContext &Ctx, const NamedDecl &ND) {
+  PrintingPolicy P(Ctx.getPrintingPolicy());
+  P.SuppressScope = true;
+  P.SuppressUnwrittenScope = true;
+  P.AnonymousTagLocations = false;
+  P.PolishForDeclaration = true;
+  std::string Detail;
+  llvm::raw_string_ostream OS(Detail);
+  if (ND.getDescribedTemplateParams()) {
+    OS << "template ";
+  }
+  if (const auto *VD = dyn_cast<ValueDecl>(&ND)) {
+    // FIXME: better printing for dependent type
+    if (isa<CXXConstructorDecl>(VD)) {
+      std::string ConstructorType = VD->getType().getAsString(P);
+      // Print constructor type as "(int)" instead of "void (int)".
+      llvm::StringRef WithoutVoid = ConstructorType;
+      WithoutVoid.consume_front("void ");
+      OS << WithoutVoid;
+    } else if (!isa<CXXDestructorDecl>(VD)) {
+      VD->getType().print(OS, P);
+    }
+  } else if (const auto *TD = dyn_cast<TagDecl>(&ND)) {
+    OS << TD->getKindName();
+  } else if (isa<TypedefNameDecl>(&ND)) {
+    OS << "type alias";
+  } else if (isa<ConceptDecl>(&ND)) {
+    OS << "concept";
+  }
+  return std::move(OS.str());
+}
+
 llvm::Optional<DocumentSymbol> declToSym(ASTContext &Ctx, const NamedDecl &ND) {
   auto &SM = Ctx.getSourceManager();
 
   SourceLocation BeginLoc = SM.getSpellingLoc(SM.getFileLoc(ND.getBeginLoc()));
   SourceLocation EndLoc = SM.getSpellingLoc(SM.getFileLoc(ND.getEndLoc()));
   const auto SymbolRange =
       toHalfOpenFileRange(SM, Ctx.getLangOpts(), {BeginLoc, EndLoc});
   if (!SymbolRange)
     return llvm::None;
 
   index::SymbolInfo SymInfo = index::getSymbolInfo(&ND);
   // FIXME: This is not classifying constructors, destructors and operators
   // correctly.
   SymbolKind SK = indexSymbolKindToSymbolKind(SymInfo.Kind);
 
   DocumentSymbol SI;
   SI.name = printName(Ctx, ND);
   SI.kind = SK;
   SI.deprecated = ND.isDeprecated();
   SI.range = Range{sourceLocToPosition(SM, SymbolRange->getBegin()),
                    sourceLocToPosition(SM, SymbolRange->getEnd())};
+  SI.detail = getSymbolDetail(Ctx, ND);
 
   SourceLocation NameLoc = ND.getLocation();
   SourceLocation FallbackNameLoc;
   if (NameLoc.isMacroID()) {
     if (isSpelledInSource(NameLoc, SM)) {
       // Prefer the spelling loc, but save the expansion loc as a fallback.
       FallbackNameLoc = SM.getExpansionLoc(NameLoc);
       NameLoc = SM.getSpellingLoc(NameLoc);

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

 # RUN: clangd --index-file=%S/Inputs/symbols.test.yaml -lit-test < %s | FileCheck %s
-{"jsonrpc":"2.0","id":0,"method":"initialize","params":{"processId":123,"rootPath":"clangd","capabilities":{"workspace":{"symbol":{"symbolKind":{"valueSet": [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26]}}}},"trace":"off"}}
+{"jsonrpc":"2.0","id":0,"method":"initialize","params":{"processId":123,"rootPath":"clangd","capabilities":{"textDocument":{"documentSymbol":{"hierarchicalDocumentSymbolSupport":true}},"workspace":{"symbol":{"symbolKind":{"valueSet": [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26]}}}},"trace":"off"}}
 ---
 {"jsonrpc":"2.0","method":"textDocument/didOpen","params":{"textDocument":{"uri":"test:///main.cpp","languageId":"cpp","version":1,"text":"void foo(); int main() { foo(); }\n"}}}
 ---
 {"jsonrpc":"2.0","id":1,"method":"workspace/symbol","params":{"query":"vector"}}
 #      CHECK:  "id": 1,
 # CHECK-NEXT:  "jsonrpc": "2.0",
 # CHECK-NEXT:    "result": [
 # CHECK-NEXT:      {

 # CHECK-NEXT:    ]
 # CHECK-NEXT:}
 ---
 {"jsonrpc":"2.0","id":2,"method":"textDocument/documentSymbol","params":{"textDocument":{"uri":"test:///main.cpp"}}}
 #      CHECK:  "id": 2,
 # CHECK-NEXT:  "jsonrpc": "2.0",
 # CHECK-NEXT:    "result": [
 # CHECK-NEXT:      {
-# CHECK-NEXT:        "containerName": "",
+# CHECK-NEXT:        "detail": "void ()",
 # CHECK-NEXT:        "kind": 12,
-# CHECK-NEXT:        "location": {
-# CHECK-NEXT:          "range": {
-# CHECK-NEXT:            "end": {
-# CHECK-NEXT:              "character": {{.*}},
-# CHECK-NEXT:              "line": {{.*}}
-# CHECK-NEXT:            },
-# CHECK-NEXT:            "start": {
-# CHECK-NEXT:              "character": {{.*}},
-# CHECK-NEXT:              "line": {{.*}}
-# CHECK-NEXT:            }
-# CHECK-NEXT:          },
-# CHECK-NEXT:          "uri": "file://{{.*}}/main.cpp"
-# CHECK-NEXT:        },
-# CHECK-NEXT:        "name": "foo"
-# CHECK-NEXT:      }
+# CHECK-NEXT:        "name": "foo",
+# CHECK-NEXT:        "range": {
+# CHECK-NEXT:          "end": {
+# CHECK-NEXT:            "character": {{.*}},
+# CHECK-NEXT:            "line": {{.*}}
+# CHECK-NEXT:          },
+# CHECK-NEXT:          "start": {
+# CHECK-NEXT:            "character": {{.*}},
+# CHECK-NEXT:            "line": {{.*}}
+# CHECK-NEXT:          }
+# CHECK-NEXT:        },
+# CHECK-NEXT:        "selectionRange": {
+# CHECK-NEXT:          "end": {
+# CHECK-NEXT:            "character": {{.*}},
+# CHECK-NEXT:            "line": {{.*}}
+# CHECK-NEXT:          },
+# CHECK-NEXT:          "start": {
+# CHECK-NEXT:            "character": {{.*}},
+# CHECK-NEXT:            "line": {{.*}}
+# CHECK-NEXT:          }
+# CHECK-NEXT:        }
+# CHECK-NEXT:      },
 # CHECK-NEXT:      {
-# CHECK-NEXT:        "containerName": "",
+# CHECK-NEXT:        "detail": "int ()",
 # CHECK-NEXT:        "kind": 12,
-# CHECK-NEXT:        "location": {
-# CHECK-NEXT:          "range": {
-# CHECK-NEXT:            "end": {
-# CHECK-NEXT:              "character": {{.*}},
-# CHECK-NEXT:              "line": {{.*}}
-# CHECK-NEXT:            },
-# CHECK-NEXT:            "start": {
-# CHECK-NEXT:              "character": {{.*}},
-# CHECK-NEXT:              "line": {{.*}}
-# CHECK-NEXT:            }
-# CHECK-NEXT:          },
-# CHECK-NEXT:          "uri": "file://{{.*}}/main.cpp"
-# CHECK-NEXT:        },
-# CHECK-NEXT:        "name": "main"
+# CHECK-NEXT:        "name": "main",
+# CHECK-NEXT:        "range": {
+# CHECK-NEXT:          "end": {
+# CHECK-NEXT:            "character": {{.*}},
+# CHECK-NEXT:            "line": {{.*}}
+# CHECK-NEXT:          },
+# CHECK-NEXT:          "start": {
+# CHECK-NEXT:            "character": {{.*}},
+# CHECK-NEXT:            "line": {{.*}}
+# CHECK-NEXT:          }
+# CHECK-NEXT:        },
+# CHECK-NEXT:        "selectionRange": {
+# CHECK-NEXT:          "end": {
+# CHECK-NEXT:            "character": {{.*}},
+# CHECK-NEXT:            "line": {{.*}}
+# CHECK-NEXT:          },
+# CHECK-NEXT:          "start": {
+# CHECK-NEXT:            "character": {{.*}},
+# CHECK-NEXT:            "line": {{.*}}
+# CHECK-NEXT:          }
+# CHECK-NEXT:        }
 # CHECK-NEXT:      }
 # CHECK-NEXT:    ]
 # CHECK-NEXT:}
 ---
 {"jsonrpc":"2.0","id":3,"method":"textDocument/documentSymbol","params":{"textDocument":{"uri":"test:///foo.cpp"}}}
 #      CHECK:  "error": {
 # CHECK-NEXT:    "code": -32602,
 # CHECK-NEXT:    "message": "trying to get AST for non-added document"
 # CHECK-NEXT:  },
 # CHECK-NEXT:  "id": 3,
 # CHECK-NEXT:  "jsonrpc": "2.0"
 ---
 {"jsonrpc":"2.0","id":3,"method":"shutdown"}
 ---
 {"jsonrpc":"2.0","method":"exit"}

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

 // GMock helpers for matching SymbolInfos items.
 MATCHER_P(QName, Name, "") {
   if (arg.containerName.empty())
     return arg.name == Name;
   return (arg.containerName + "::" + arg.name) == Name;
 }
 MATCHER_P(WithName, N, "") { return arg.name == N; }
 MATCHER_P(WithKind, Kind, "") { return arg.kind == Kind; }
+MATCHER_P(WithDetail, Detail, "") { return arg.detail == Detail; }
 MATCHER_P(SymRange, Range, "") { return arg.range == Range; }
 
 // GMock helpers for matching DocumentSymbol.
 MATCHER_P(SymNameRange, Range, "") { return arg.selectionRange == Range; }
 template <class... ChildMatchers>
 ::testing::Matcher<DocumentSymbol> Children(ChildMatchers... ChildrenM) {
   return Field(&DocumentSymbol::children, ElementsAre(ChildrenM...));
 }
Annotations Main(R"(
       using bar::v2;
       } // namespace foo
     )");
 
   TU.Code = Main.code().str();
   EXPECT_THAT(
       getSymbols(TU.build()),
       ElementsAreArray(
-          {AllOf(WithName("Foo"), WithKind(SymbolKind::Class), Children()),
+          {AllOf(WithName("Foo"), WithKind(SymbolKind::Class),
+                 WithDetail("class"), Children()),
            AllOf(WithName("Foo"), WithKind(SymbolKind::Class),
-                 Children(AllOf(WithName("Foo"),
-                                WithKind(SymbolKind::Constructor), Children()),
-                          AllOf(WithName("Foo"),
-                                WithKind(SymbolKind::Constructor), Children()),
-                          AllOf(WithName("f"), WithKind(SymbolKind::Method),
-                                Children()),
-                          AllOf(WithName("operator="),
-                                WithKind(SymbolKind::Method), Children()),
-                          AllOf(WithName("~Foo"),
-                                WithKind(SymbolKind::Constructor), Children()),
-                          AllOf(WithName("Nested"), WithKind(SymbolKind::Class),
-                                Children(AllOf(WithName("f"),
-                                               WithKind(SymbolKind::Method),
-                                               Children()))))),
-           AllOf(WithName("Friend"), WithKind(SymbolKind::Class), Children()),
-           AllOf(WithName("f1"), WithKind(SymbolKind::Function), Children()),
-           AllOf(WithName("f2"), WithKind(SymbolKind::Function), Children()),
-           AllOf(WithName("KInt"), WithKind(SymbolKind::Variable), Children()),
-           AllOf(WithName("kStr"), WithKind(SymbolKind::Variable), Children()),
-           AllOf(WithName("f1"), WithKind(SymbolKind::Function), Children()),
+                 WithDetail("class"),
+                 Children(
+                     AllOf(WithName("Foo"), WithKind(SymbolKind::Constructor),
+                           WithDetail("()"), Children()),
+                     AllOf(WithName("Foo"), WithKind(SymbolKind::Constructor),
+                           WithDetail("(int)"), Children()),
+                           WithDetail("void ()"), Children()),
+                     AllOf(WithName("operator="), WithKind(SymbolKind::Method),
+                           WithDetail("Foo &(const Foo &)"), Children()),
+                     AllOf(WithName("~Foo"), WithKind(SymbolKind::Constructor),
+                           WithDetail(""), Children()),
+                           WithDetail("class"),
+                           Children(AllOf(
+                               WithName("f"), WithKind(SymbolKind::Method),
+                               WithDetail("void ()"), Children()))))),
+           AllOf(WithName("Friend"), WithKind(SymbolKind::Class),
+                 WithDetail("class"), Children()),
+           AllOf(WithName("f1"), WithKind(SymbolKind::Function),
+                 WithDetail("void ()"), Children()),
+           AllOf(WithName("f2"), WithKind(SymbolKind::Function),
+                 WithDetail("void ()"), Children()),
+           AllOf(WithName("KInt"), WithKind(SymbolKind::Variable),
+                 WithDetail("const int"), Children()),
+           AllOf(WithName("kStr"), WithKind(SymbolKind::Variable),
+                 WithDetail("const char *"), Children()),
+           AllOf(WithName("f1"), WithKind(SymbolKind::Function),
+                 WithDetail("void ()"), Children()),
            AllOf(
-               WithName("foo"), WithKind(SymbolKind::Namespace),
-               Children(
-                   AllOf(WithName("int32"), WithKind(SymbolKind::Class),
-                         Children()),
+               WithName("foo"), WithKind(SymbolKind::Namespace), WithDetail(""),
+               Children(AllOf(WithName("int32"), WithKind(SymbolKind::Class),
+                              WithDetail("type alias"), Children()),
                         AllOf(WithName("int32_t"), WithKind(SymbolKind::Class),
-                         Children()),
+                              WithDetail("type alias"), Children()),
                         AllOf(WithName("v1"), WithKind(SymbolKind::Variable),
-                         Children()),
+                              WithDetail("int"), Children()),
                         AllOf(WithName("bar"), WithKind(SymbolKind::Namespace),
+                              WithDetail(""),
                               Children(AllOf(WithName("v2"),
                                              WithKind(SymbolKind::Variable),
-                                        Children()))),
+                                             WithDetail("int"), Children()))),
                         AllOf(WithName("baz"), WithKind(SymbolKind::Namespace),
-                         Children()),
-                   AllOf(WithName("v2"), WithKind(SymbolKind::Namespace))))}));
+                              WithDetail(""), Children()),
+                        AllOf(WithName("v2"), WithKind(SymbolKind::Namespace),
+                              WithDetail(""))))}));
 }
 
 TEST(DocumentSymbols, DeclarationDefinition) {
   TestTU TU;
   Annotations Main(R"(
       class Foo {
         void $decl[[f]]();
       };
       void Foo::$def[[f]]() {
       }
     )");
 
   TU.Code = Main.code().str();
   EXPECT_THAT(
       getSymbols(TU.build()),
       ElementsAre(
           AllOf(WithName("Foo"), WithKind(SymbolKind::Class),
+                WithDetail("class"),
                 Children(AllOf(WithName("f"), WithKind(SymbolKind::Method),
+                               WithDetail("void ()"),
                                SymNameRange(Main.range("decl"))))),
           AllOf(WithName("Foo::f"), WithKind(SymbolKind::Method),
-                SymNameRange(Main.range("def")))));
+                WithDetail("void ()"), SymNameRange(Main.range("def")))));
 }
 
 TEST(DocumentSymbols, Concepts) {
   TestTU TU;
   TU.ExtraArgs = {"-std=c++20"};
   TU.Code = "template <typename T> concept C = requires(T t) { t.foo(); };";
 
-  EXPECT_THAT(getSymbols(TU.build()), ElementsAre(WithName("C")));
+  EXPECT_THAT(getSymbols(TU.build()),
+              ElementsAre(AllOf(WithName("C"), WithDetail("concept"))));
 }
 
 TEST(DocumentSymbols, ExternSymbol) {
   TestTU TU;
   TU.AdditionalFiles["foo.h"] = R"cpp(
       extern int var;
       )cpp";
   TU.Code = R"cpp(
TU.Code = R"cpp(
       })cpp";
 
   EXPECT_THAT(getSymbols(TU.build()),
               ElementsAre(WithName("foo"), WithName("Foo"),
                           AllOf(WithName("ns"),
                                 Children(WithName("bar"), WithName("Bar")))));
 }
 
 TEST(DocumentSymbols, ExportContext) {
   TestTU TU;
   TU.ExtraArgs = {"-std=c++20"};
   TU.Code = R"cpp(
       export module test;
       export {
       void foo();
       class Foo {};
       })cpp";
TEST(DocumentSymbols, Unnamed) {
   TestTU TU;
   TU.Code = R"cpp(
       struct {
         int InUnnamed;
       } UnnamedStruct;
       )cpp";
   EXPECT_THAT(
       getSymbols(TU.build()),
-      ElementsAre(
-          AllOf(WithName("(anonymous struct)"), WithKind(SymbolKind::Struct),
+      ElementsAre(AllOf(WithName("(anonymous struct)"),
+                        WithKind(SymbolKind::Struct), WithDetail("struct"),
                         Children(AllOf(WithName("InUnnamed"),
-                               WithKind(SymbolKind::Field), Children()))),
-          AllOf(WithName("UnnamedStruct"), WithKind(SymbolKind::Variable),
-                Children())));
+                                       WithKind(SymbolKind::Field),
+                                       WithDetail("int"), Children()))),
+                  AllOf(WithName("UnnamedStruct"),
+                        WithKind(SymbolKind::Variable),
+                        WithDetail("struct (anonymous)"), Children())));
 }
 
 TEST(DocumentSymbols, InHeaderFile) {
   TestTU TU;
   TU.AdditionalFiles["bar.h"] = R"cpp(
       int foo() {
       }
       )cpp";
TU.Code = R"(
     int varTmpl = T();
     template <>
     double varTmpl<int> = 10.0;
   )";
   EXPECT_THAT(
       getSymbols(TU.build()),
       ElementsAre(
           AllOf(WithName("Tmpl"), WithKind(SymbolKind::Struct),
-                Children(AllOf(WithName("x"), WithKind(SymbolKind::Field)))),
+                WithDetail("template struct"),
+                Children(AllOf(WithName("x"), WithKind(SymbolKind::Field),
+                               WithDetail("T")))),
           AllOf(WithName("Tmpl<int>"), WithKind(SymbolKind::Struct),
-                Children(WithName("y"))),
+                WithDetail("struct"),
+                Children(AllOf(WithName("y"), WithDetail("int")))),
           AllOf(WithName("Tmpl<float>"), WithKind(SymbolKind::Struct),
-                Children()),
+                WithDetail("struct"), Children()),
           AllOf(WithName("Tmpl<double>"), WithKind(SymbolKind::Struct),
+                WithDetail("struct"), Children()),
+          AllOf(WithName("funcTmpl"), WithDetail("template int (U)"),
+                Children()),
+          AllOf(WithName("funcTmpl<int>"), WithDetail("int (double)"),
                 Children()),
-          AllOf(WithName("funcTmpl"), Children()),
-          AllOf(WithName("funcTmpl<int>"), Children()),
-          AllOf(WithName("varTmpl"), Children()),
-          AllOf(WithName("varTmpl<int>"), Children())));
+          AllOf(WithName("varTmpl"), WithDetail("template int"), Children()),
+          AllOf(WithName("varTmpl<int>"), WithDetail("double"), Children())));
 }
 
 TEST(DocumentSymbols, Namespaces) {
   TestTU TU;
   TU.Code = R"cpp(
       namespace ans1 {
         int ai1;
       namespace ans2 {
EXPECT_THAT(
       ElementsAreArray<::testing::Matcher<DocumentSymbol>>(
           {AllOf(WithName("ans1"),
                  Children(AllOf(WithName("ai1"), Children()),
                           AllOf(WithName("ans2"), Children(WithName("ai2"))))),
            AllOf(WithName("(anonymous namespace)"), Children(WithName("test"))),
            AllOf(WithName("na"),
                  Children(AllOf(WithName("nb"), Children(WithName("Foo"))))),
            AllOf(WithName("na"),
                  Children(AllOf(WithName("nb"), Children(WithName("Bar")))))}));
 }
 
 TEST(DocumentSymbols, Enums) {
   TestTU TU;
   TU.Code = R"(
       enum {
         Red
       };
       enum Color {
         Green
       };
       enum class Color2 {
         Yellow
       };
       namespace ns {
       enum {
         Black
       };
       }
     )";
   EXPECT_THAT(
       getSymbols(TU.build()),
       ElementsAre(
-          AllOf(WithName("(anonymous enum)"), Children(WithName("Red"))),
-          AllOf(WithName("Color"), Children(WithName("Green"))),
-          AllOf(WithName("Color2"), Children(WithName("Yellow"))),
-          AllOf(WithName("ns"), Children(AllOf(WithName("(anonymous enum)"),
-                                               Children(WithName("Black")))))));
+          AllOf(WithName("(anonymous enum)"), WithDetail("enum"),
+                Children(AllOf(WithName("Red"), WithDetail("(anonymous)")))),
+          AllOf(WithName("Color"), WithDetail("enum"),
+                Children(AllOf(WithName("Green"), WithDetail("Color")))),
+          AllOf(WithName("Color2"), WithDetail("enum"),
+                Children(AllOf(WithName("Yellow"), WithDetail("Color2")))),
+          AllOf(WithName("ns"),
+                Children(AllOf(WithName("(anonymous enum)"), WithDetail("enum"),
+                               Children(AllOf(WithName("Black"),
+                                              WithDetail("(anonymous)"))))))));
 }
 
 TEST(DocumentSymbols, FromMacro) {
   TestTU TU;
   Annotations Main(R"(
     #define FF(name) \
       class name##_Test {};
 
     $expansion1[[FF]](abc);
 
     #define FF2() \
       class Test {};
 
     $expansion2[[FF2]]();
 
     #define FF3() \
       void waldo()
 
     $fullDef[[FF3() {
       int var = 42;
     }]]
   )");
   TU.Code = Main.code().str();
-  EXPECT_THAT(
-      getSymbols(TU.build()),
-      ElementsAre(
-          AllOf(WithName("abc_Test"), SymNameRange(Main.range("expansion1"))),
-          AllOf(WithName("Test"), SymNameRange(Main.range("expansion2"))),
-          AllOf(WithName("waldo"), SymRange(Main.range("fullDef")))));
+  EXPECT_THAT(getSymbols(TU.build()),
+              ElementsAre(AllOf(WithName("abc_Test"), WithDetail("class"),
+                                SymNameRange(Main.range("expansion1"))),
+                          AllOf(WithName("Test"), WithDetail("class"),
+                                SymNameRange(Main.range("expansion2"))),
+                          AllOf(WithName("waldo"), WithDetail("void ()"),
+                                SymRange(Main.range("fullDef")))));
 }
 
 TEST(DocumentSymbols, FuncTemplates) {
   TestTU TU;
   Annotations Source(R"cpp(
     template <class T>
     T foo() {}
 
     auto x = foo<int>();
     auto y = foo<double>();
   )cpp");
   TU.Code = Source.code().str();
   // Make sure we only see the template declaration, not instantiations.
   EXPECT_THAT(getSymbols(TU.build()),
-              ElementsAre(WithName("foo"), WithName("x"), WithName("y")));
+              ElementsAre(AllOf(WithName("foo"), WithDetail("template T ()")),
+                          AllOf(WithName("x"), WithDetail("int")),
+                          AllOf(WithName("y"), WithDetail("double"))));
 }
 
 TEST(DocumentSymbols, UsingDirectives) {
   TestTU TU;
   Annotations Source(R"cpp(
     namespace ns {
       int foo;
     }
TEST(DocumentSymbols, TempSpecs) {
   TestTU TU;
   TU.Code = R"cpp(
       template <typename T, typename U, int X = 5> class Foo {};
       template <typename T> class Foo<int, T> {};
       template <> class Foo<bool, int> {};
       template <> class Foo<bool, int, 3> {};
       )cpp";
   // Foo is higher ranked because of exact name match.
-  EXPECT_THAT(
-      getSymbols(TU.build()),
+  EXPECT_THAT(getSymbols(TU.build()),
               UnorderedElementsAre(
-          AllOf(WithName("Foo"), WithKind(SymbolKind::Class)),
-          AllOf(WithName("Foo<int, T>"), WithKind(SymbolKind::Class)),
-          AllOf(WithName("Foo<bool, int>"), WithKind(SymbolKind::Class)),
-          AllOf(WithName("Foo<bool, int, 3>"), WithKind(SymbolKind::Class))));
+                  AllOf(WithName("Foo"), WithKind(SymbolKind::Class),
+                        WithDetail("template class")),
+                  AllOf(WithName("Foo<int, T>"), WithKind(SymbolKind::Class),
+                        WithDetail("template class")),
+                  AllOf(WithName("Foo<bool, int>"), WithKind(SymbolKind::Class),
+                        WithDetail("class")),
+                  AllOf(WithName("Foo<bool, int, 3>"),
+                        WithKind(SymbolKind::Class), WithDetail("class"))));
 }
 
 TEST(DocumentSymbols, Qualifiers) {
   TestTU TU;
   TU.Code = R"cpp(
     namespace foo { namespace bar {
       struct Cls;
 
TU.Code = R"cpp(
 
       // Default arguments should not be shown!
       int Foo<int>::method2() { return 20; }
 
       using Foo_type = Foo<int>;
       // If the whole type is aliased, this should be preserved too!
       int Foo_type::method3() { return 30; }
       )cpp";
-  EXPECT_THAT(
-      getSymbols(TU.build()),
-      UnorderedElementsAre(WithName("Foo"), WithName("Foo<int, double>"),
-                           WithName("int_type"),
-                           WithName("Foo<int_type, double>::method1"),
-                           WithName("Foo<int>::method2"), WithName("Foo_type"),
-                           WithName("Foo_type::method3")));
+  EXPECT_THAT(getSymbols(TU.build()),
+              UnorderedElementsAre(
+                  AllOf(WithName("Foo"), WithDetail("template class")),
+                  AllOf(WithName("Foo<int, double>"), WithDetail("class")),
+                  AllOf(WithName("int_type"), WithDetail("type alias")),
+                  AllOf(WithName("Foo<int_type, double>::method1"),
+                        WithDetail("int ()")),
+                  AllOf(WithName("Foo<int>::method2"), WithDetail("int ()")),
+                  AllOf(WithName("Foo_type"), WithDetail("type alias")),
+                  AllOf(WithName("Foo_type::method3"), WithDetail("int ()"))));
 }
 
 TEST(DocumentSymbolsTest, Ranges) {
   TestTU TU;
   Annotations Main(R"(
       $foo[[int foo(bool Argument) {
         return 42;
       }]]
Annotations Main(R"(
 
       $forwardfunc[[void forwardFunctionDecl(int Something)]];
     )");
   TU.Code = Main.code().str();
   EXPECT_THAT(
       getSymbols(TU.build()),
       UnorderedElementsAre(
           AllOf(WithName("foo"), WithKind(SymbolKind::Function),
-                SymRange(Main.range("foo"))),
+                WithDetail("int (bool)"), SymRange(Main.range("foo"))),
           AllOf(WithName("GLOBAL_VARIABLE"), WithKind(SymbolKind::Variable),
-                SymRange(Main.range("variable"))),
+                WithDetail("char"), SymRange(Main.range("variable"))),
           AllOf(
               WithName("ns"), WithKind(SymbolKind::Namespace),
               SymRange(Main.range("ns")),
               Children(AllOf(
                   WithName("Bar"), WithKind(SymbolKind::Class),
-                  SymRange(Main.range("bar")),
+                  WithDetail("class"), SymRange(Main.range("bar")),
                   Children(
                       AllOf(WithName("Bar"), WithKind(SymbolKind::Constructor),
-                            SymRange(Main.range("ctor"))),
+                            WithDetail("()"), SymRange(Main.range("ctor"))),
                       AllOf(WithName("~Bar"), WithKind(SymbolKind::Constructor),
-                            SymRange(Main.range("dtor"))),
+                            WithDetail(""), SymRange(Main.range("dtor"))),
                       AllOf(WithName("Baz"), WithKind(SymbolKind::Field),
+                            WithDetail("unsigned int"),
                             SymRange(Main.range("field"))),
                       AllOf(WithName("getBaz"), WithKind(SymbolKind::Method),
+                            WithDetail("unsigned int ()"),
                             SymRange(Main.range("getbaz"))))))),
           AllOf(WithName("ForwardClassDecl"), WithKind(SymbolKind::Class),
-                SymRange(Main.range("forwardclass"))),
+                WithDetail("class"), SymRange(Main.range("forwardclass"))),
           AllOf(WithName("StructDefinition"), WithKind(SymbolKind::Struct),
-                SymRange(Main.range("struct")),
+                WithDetail("struct"), SymRange(Main.range("struct")),
                 Children(AllOf(WithName("Pointer"), WithKind(SymbolKind::Field),
+                               WithDetail("int *"),
                                SymRange(Main.range("structfield"))))),
           AllOf(WithName("StructDeclaration"), WithKind(SymbolKind::Struct),
-                SymRange(Main.range("forwardstruct"))),
+                WithDetail("struct"), SymRange(Main.range("forwardstruct"))),
           AllOf(WithName("forwardFunctionDecl"), WithKind(SymbolKind::Function),
+                WithDetail("void (int)"),
                 SymRange(Main.range("forwardfunc")))));
 }
 
+TEST(DocumentSymbolsTest, DependentType) {
+  TestTU TU;
+  TU.Code = R"(
+    template <typename T> auto plus(T x, T y) -> decltype(x + y) { return x + y; }
+
+    template <typename Key, typename Value> class Pair {};
+
+    template <typename Key, typename Value>
+    struct Context : public Pair<Key, Value> {
+      using Pair<Key, Value>::Pair;
+    };
+    )";
+  EXPECT_THAT(
+      getSymbols(TU.build()),
+      ElementsAre(
+          AllOf(WithName("plus"),
+                WithDetail("template auto (T, T) -> decltype(x + y)")),
+          AllOf(WithName("Pair"), WithDetail("template class")),
+          AllOf(WithName("Context"), WithDetail("template struct"),
+                Children(AllOf(
+                    WithName("Pair<type-parameter-0-0, type-parameter-0-1>"),
+                    WithDetail("<dependent type>"))))));
+}
+
 } // namespace
 } // namespace clangd
 } // namespace clang