[clangd] Show template argument list in workspacesymbols and documentsymbols responses

[kadircet]

Summary

Last part of re-landing rC356541. Puts TemplateArgumentsList into
responses of the above mentioned two requests.

[ilya-biryukov]

LG, just have a simple clarifying question.

clang-tools-extra/clangd/AST.cpp

112 ↗

(On Diff #191680)

Where did this FIXME go? Is this now fixed?

[kadircet]

clang-tools-extra/clangd/AST.cpp

112 ↗

(On Diff #191680)

Yes, since printTemplateArgsAsWritten prints the args as written in the code(see changes in file clang-tools-extra/unittests/clangd/FindSymbolsTests.cpp, especially the tests with a FIXME).

Of course it still has the caveat of frienddecls, but I think the fixme inside printTemplateArgsAswritten is the one covering that case, not this one.

[kadircet]

• Rebase

[kadircet]

clang-tools-extra/clangd/AST.cpp

112 ↗

(On Diff #191680)

This part of the change has been incorporated into parent change at D59639 per reviewer's request.

[ilya-biryukov]

clang-tools-extra/clangd/AST.cpp

112 ↗

(On Diff #191680)

LG. Just wanted to make sure it's not lost. Thanks!

clang-tools-extra/trunk/clangd/FindSymbols.cpp

Index->fuzzyFind(Req, [HintPath, &Top, &Filter](const Symbol &Sym) {
     Start.character = CD.Start.column();
     End.line = CD.End.line();
     End.character = CD.End.column();
     L.range = {Start, End};
     SymbolKind SK = indexSymbolKindToSymbolKind(Sym.SymInfo.Kind);
     std::string Scope = Sym.Scope;
     llvm::StringRef ScopeRef = Scope;
     ScopeRef.consume_back("::");
-    SymbolInformation Info = {Sym.Name, SK, L, ScopeRef};
+    SymbolInformation Info = {(Sym.Name + Sym.TemplateSpecializationArgs).str(),
+                              SK, L, ScopeRef};
 
     SymbolQualitySignals Quality;
     Quality.merge(Sym);
     SymbolRelevanceSignals Relevance;
     Relevance.Query = SymbolRelevanceSignals::Generic;
     if (auto NameMatch = Filter.match(Sym.Name))
       Relevance.NameMatch = *NameMatch;
     else {

clang-tools-extra/trunk/clangd/index/MemIndex.cpp

bool MemIndex::fuzzyFind(
 
   TopN<std::pair<float, const Symbol *>> Top(
       Req.Limit ? *Req.Limit : std::numeric_limits<size_t>::max());
   FuzzyMatcher Filter(Req.Query);
   bool More = false;
   for (const auto Pair : Index) {
     const Symbol *Sym = Pair.second;
 
-    // FIXME: Enable fuzzy find on template specializations once we start
-    // storing template arguments in the name. Currently we only store name for
-    // class template, which would cause duplication in the results.
-    if (Sym->SymInfo.Properties &
-        (static_cast<index::SymbolPropertySet>(
-             index::SymbolProperty::TemplateSpecialization) |
-         static_cast<index::SymbolPropertySet>(
-             index::SymbolProperty::TemplatePartialSpecialization)))
-      continue;
     // Exact match against all possible scopes.
     if (!Req.AnyScope && !llvm::is_contained(Req.Scopes, Sym->Scope))
       continue;
     if (Req.RestrictForCodeCompletion &&
         !(Sym->Flags & Symbol::IndexedForCodeCompletion))
       continue;
 
     if (auto Score = Filter.match(Sym->Name))

clang-tools-extra/trunk/clangd/index/dex/Dex.cpp

for (size_t I = 0; I < ScoredSymbols.size(); ++I) {
     SymbolQuality[I] = ScoredSymbols[I].first;
     Symbols[I] = ScoredSymbols[I].second;
   }
 
   // Populate TempInvertedIndex with lists for index symbols.
   llvm::DenseMap<Token, std::vector<DocID>> TempInvertedIndex;
   for (DocID SymbolRank = 0; SymbolRank < Symbols.size(); ++SymbolRank) {
     const auto *Sym = Symbols[SymbolRank];
-    // FIXME: Enable fuzzy find on template specializations once we start
-    // storing template arguments in the name. Currently we only store name for
-    // class template, which would cause duplication in the results.
-    if (Sym->SymInfo.Properties &
-        (static_cast<index::SymbolPropertySet>(
-             index::SymbolProperty::TemplateSpecialization) |
-         static_cast<index::SymbolPropertySet>(
-             index::SymbolProperty::TemplatePartialSpecialization)))
-      continue;
     for (const auto &Token : generateSearchTokens(*Sym))
       TempInvertedIndex[Token].push_back(SymbolRank);
   }
 
   // Convert lists of items to posting lists.
   for (const auto &TokenToPostingList : TempInvertedIndex)
     InvertedIndex.insert(
         {TokenToPostingList.first, PostingList(TokenToPostingList.second)});

clang-tools-extra/trunk/unittests/clangd/DexTests.cpp

 //===-- DexTests.cpp  ---------------------------------*- 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 "FuzzyMatch.h"
 #include "TestFS.h"
 #include "TestIndex.h"
 #include "index/Index.h"
 #include "index/Merge.h"
+#include "index/SymbolID.h"
 #include "index/dex/Dex.h"
 #include "index/dex/Iterator.h"
 #include "index/dex/Token.h"
 #include "index/dex/Trigram.h"
 #include "llvm/Support/ScopedPrinter.h"
 #include "llvm/Support/raw_ostream.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include <string>
 #include <vector>
 
 using ::testing::AnyOf;
 using ::testing::ElementsAre;
+using ::testing::IsEmpty;
 using ::testing::UnorderedElementsAre;
 
 namespace clang {
 namespace clangd {
 namespace dex {
 namespace {
 
 //===----------------------------------------------------------------------===//
TEST(DexTest, TemplateSpecialization) {
   SymbolSlab::Builder B;
 
   Symbol S = symbol("TempSpec");
   S.ID = SymbolID("0");
   B.insert(S);
 
   S = symbol("TempSpec");
   S.ID = SymbolID("1");
+  S.TemplateSpecializationArgs = "<int, bool>";
   S.SymInfo.Properties = static_cast<index::SymbolPropertySet>(
       index::SymbolProperty::TemplateSpecialization);
   B.insert(S);
 
   S = symbol("TempSpec");
   S.ID = SymbolID("2");
+  S.TemplateSpecializationArgs = "<int, U>";
   S.SymInfo.Properties = static_cast<index::SymbolPropertySet>(
       index::SymbolProperty::TemplatePartialSpecialization);
   B.insert(S);
 
   auto I = dex::Dex::build(std::move(B).build(), RefSlab());
   FuzzyFindRequest Req;
-  Req.Query = "TempSpec";
   Req.AnyScope = true;
 
-  std::vector<Symbol> Symbols;
-  I->fuzzyFind(Req, [&Symbols](const Symbol &Sym) { Symbols.push_back(Sym); });
-  EXPECT_EQ(Symbols.size(), 1U);
-  EXPECT_FALSE(Symbols.front().SymInfo.Properties &
-               static_cast<index::SymbolPropertySet>(
-                   index::SymbolProperty::TemplateSpecialization));
-  EXPECT_FALSE(Symbols.front().SymInfo.Properties &
-               static_cast<index::SymbolPropertySet>(
-                   index::SymbolProperty::TemplatePartialSpecialization));
+  Req.Query = "TempSpec";
+  EXPECT_THAT(match(*I, Req),
+              UnorderedElementsAre("TempSpec", "TempSpec<int, bool>",
+                                   "TempSpec<int, U>"));
+
+  // FIXME: Add filtering for template argument list.
+  Req.Query = "TempSpec<int";
+  EXPECT_THAT(match(*I, Req), IsEmpty());
 }
 
 } // namespace
 } // namespace dex
 } // namespace clangd
 } // namespace clang

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

EXPECT_THAT(getSymbols("InUnnamed"),
                                 WithKind(SymbolKind::Field))));
 }
 
 TEST_F(WorkspaceSymbolsTest, InMainFile) {
   addFile("foo.cpp", R"cpp(
       int test() {}
       static test2() {}
       )cpp");
-  EXPECT_THAT(getSymbols("test"), 
-              ElementsAre(QName("test"), QName("test2")));
+  EXPECT_THAT(getSymbols("test"), ElementsAre(QName("test"), QName("test2")));
 }
 
 TEST_F(WorkspaceSymbolsTest, Namespaces) {
   addFile("foo.h", R"cpp(
       namespace ans1 {
         int ai1;
       namespace ans2 {
         int ai2;
EXPECT_THAT(getSymbols("foo"),
               UnorderedElementsAre(
                   AllOf(QName("foo"), WithKind(SymbolKind::Variable)),
                   AllOf(QName("foo2"), WithKind(SymbolKind::Variable))));
 
   Limit = 1;
   EXPECT_THAT(getSymbols("foo"), ElementsAre(QName("foo")));
 }
 
+TEST_F(WorkspaceSymbolsTest, TempSpecs) {
+  addFile("foo.h", 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("Foo"),
+      UnorderedElementsAre(
+          AllOf(QName("Foo"), WithKind(SymbolKind::Class)),
+          AllOf(QName("Foo<int, T>"), WithKind(SymbolKind::Class)),
+          AllOf(QName("Foo<bool, int>"), WithKind(SymbolKind::Class)),
+          AllOf(QName("Foo<bool, int, 3>"), WithKind(SymbolKind::Class))));
+}
+
 namespace {
 class DocumentSymbolsTest : public ::testing::Test {
 public:
   DocumentSymbolsTest()
       : Server(CDB, FSProvider, DiagConsumer, optsForTests()) {}
 
 protected:
   MockFSProvider FSProvider;
TEST_F(DocumentSymbolsTest, UsingDirectives) {
   )cpp");
   addFile(FilePath, Source.code());
   EXPECT_THAT(getSymbols(FilePath),
               ElementsAre(WithName("ns"), WithName("ns_alias"),
                           WithName("using namespace ::ns"),
                           WithName("using namespace ns_alias")));
 }
 
+TEST_F(DocumentSymbolsTest, TempSpecs) {
+  addFile("foo.cpp", 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("foo.cpp"),
+      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))));
+}
+
 } // namespace clangd
 } // namespace clang

clang-tools-extra/trunk/unittests/clangd/IndexTests.cpp

 #include "clang/Index/IndexSymbol.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
 using testing::_;
 using testing::AllOf;
 using testing::AnyOf;
 using testing::ElementsAre;
+using testing::IsEmpty;
 using testing::Pair;
 using testing::Pointee;
 using testing::UnorderedElementsAre;
 
 namespace clang {
 namespace clangd {
 namespace {
 
EXPECT_THAT(lookup(*I, {SymbolID("ns::nonono"), SymbolID("ns::xyz")}),
               UnorderedElementsAre("ns::xyz"));
   EXPECT_THAT(lookup(*I, SymbolID("ns::nonono")), UnorderedElementsAre());
 }
 
 TEST(MemIndexTest, TemplateSpecialization) {
   SymbolSlab::Builder B;
 
   Symbol S = symbol("TempSpec");
-  S.ID = SymbolID("0");
+  S.ID = SymbolID("1");
   B.insert(S);
 
   S = symbol("TempSpec");
-  S.ID = SymbolID("1");
+  S.ID = SymbolID("2");
+  S.TemplateSpecializationArgs = "<int, bool>";
   S.SymInfo.Properties = static_cast<index::SymbolPropertySet>(
       index::SymbolProperty::TemplateSpecialization);
   B.insert(S);
 
   S = symbol("TempSpec");
-  S.ID = SymbolID("2");
+  S.ID = SymbolID("3");
+  S.TemplateSpecializationArgs = "<int, U>";
   S.SymInfo.Properties = static_cast<index::SymbolPropertySet>(
       index::SymbolProperty::TemplatePartialSpecialization);
   B.insert(S);
 
   auto I = MemIndex::build(std::move(B).build(), RefSlab());
   FuzzyFindRequest Req;
-  Req.Query = "TempSpec";
   Req.AnyScope = true;
 
-  std::vector<Symbol> Symbols;
-  I->fuzzyFind(Req, [&Symbols](const Symbol &Sym) { Symbols.push_back(Sym); });
-  EXPECT_EQ(Symbols.size(), 1U);
-  EXPECT_FALSE(Symbols.front().SymInfo.Properties &
-               static_cast<index::SymbolPropertySet>(
-                   index::SymbolProperty::TemplateSpecialization));
-  EXPECT_FALSE(Symbols.front().SymInfo.Properties &
-               static_cast<index::SymbolPropertySet>(
-                   index::SymbolProperty::TemplatePartialSpecialization));
+  Req.Query = "TempSpec";
+  EXPECT_THAT(match(*I, Req),
+              UnorderedElementsAre("TempSpec", "TempSpec<int, bool>",
+                                   "TempSpec<int, U>"));
+
+  // FIXME: Add filtering for template argument list.
+  Req.Query = "TempSpec<int";
+  EXPECT_THAT(match(*I, Req), IsEmpty());
 }
 
 TEST(MergeIndexTest, Lookup) {
   auto I = MemIndex::build(generateSymbols({"ns::A", "ns::B"}), RefSlab()),
        J = MemIndex::build(generateSymbols({"ns::B", "ns::C"}), RefSlab());
   MergedIndex M(I.get(), J.get());
   EXPECT_THAT(lookup(M, SymbolID("ns::A")), UnorderedElementsAre("ns::A"));
   EXPECT_THAT(lookup(M, SymbolID("ns::B")), UnorderedElementsAre("ns::B"));

clang-tools-extra/trunk/unittests/clangd/TestIndex.cpp

 SymbolSlab generateNumSymbols(int Begin, int End) {
   std::vector<std::string> Names;
   for (int i = Begin; i <= End; i++)
     Names.push_back(std::to_string(i));
   return generateSymbols(Names);
 }
 
 std::string getQualifiedName(const Symbol &Sym) {
-  return (Sym.Scope + Sym.Name).str();
+  return (Sym.Scope + Sym.Name + Sym.TemplateSpecializationArgs).str();
 }
 
 std::vector<std::string> match(const SymbolIndex &I,
                                const FuzzyFindRequest &Req, bool *Incomplete) {
   std::vector<std::string> Matches;
   bool IsIncomplete = I.fuzzyFind(Req, [&](const Symbol &Sym) {
     Matches.push_back(clang::clangd::getQualifiedName(Sym));
   });