[clangd] Store index::SymbolKind in HoverInfo

[kadircet]

Summary

LSP's SymbolKind has some shortcomings when it comes to C++ types,
index::SymbolKind has more detailed info like Destructor, Parameter, MACRO etc.

We are planning to make use of that information in our new Hover response, and
it would be nice to display the Symbol type in full detail, rather than some
approximation.

[merge_guards_bot]

Build result: pass - 60291 tests passed, 0 failed and 732 were skipped.

Log files: console-log.txt, CMakeCache.txt

[sammccall]

clang-tools-extra/clangd/Hover.cpp

363

just Kind = Macro seems clearer...

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

473

(FWIW, both the old and the new value here seem suspect - this isn't a property)

[kadircet]

• Address comments

[merge_guards_bot]

Build result: pass - 60506 tests passed, 0 failed and 726 were skipped.

Log files: console-log.txt, CMakeCache.txt

clang-tools-extra/clangd/Hover.h

 struct HoverInfo {
   /// Represents parameters of a function, a template or a macro.
   /// For example:
   /// - void foo(ParamType Name = DefaultValue)
   /// - #define FOO(Name)
   /// - template <ParamType Name = DefaultType> class Foo {};
   struct Param {
     /// The pretty-printed parameter type, e.g. "int", or "typename" (in
-    /// TemplateParameters)
+    /// TemplateParameters), might be None for macro parameters.
     llvm::Optional<std::string> Type;
     /// None for unnamed parameters.
     llvm::Optional<std::string> Name;
     /// None if no default is provided.
     llvm::Optional<std::string> Default;
   };
 
   /// For a variable named Bar, declared in clang::clangd::Foo::getFoo the
   /// following fields will hold:
   /// - NamespaceScope: clang::clangd::
   /// - LocalScope: Foo::getFoo::
   /// - Name: Bar
 
   /// Scopes might be None in cases where they don't make sense, e.g. macros and
   /// auto/decltype.
   /// Contains all of the enclosing namespaces, empty string means global
   /// namespace.
   llvm::Optional<std::string> NamespaceScope;
   /// Remaining named contexts in symbol's qualified name, empty string means
   /// symbol is not local.
   std::string LocalScope;
   /// Name of the symbol, does not contain any "::".
   std::string Name;
   llvm::Optional<Range> SymRange;
-  /// Scope containing the symbol. e.g, "global namespace", "function x::Y"
-  /// - None for deduced types, e.g "auto", "decltype" keywords.
-  SymbolKind Kind;
+  index::SymbolKind Kind;
   std::string Documentation;
   /// Source code containing the definition of the symbol.
   std::string Definition;
 
   /// Pretty-printed variable type.
   /// Set only for variables.
   llvm::Optional<std::string> Type;
   /// Set for functions and lambadas.

clang-tools-extra/clangd/Hover.cpp

 #include "Selection.h"
 #include "SourceCode.h"
 #include "index/SymbolCollector.h"
 
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ASTTypeTraits.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/PrettyPrinter.h"
+#include "clang/Index/IndexSymbol.h"
+#include "llvm/Support/raw_ostream.h"
 
 namespace clang {
 namespace clangd {
 namespace {
 
 PrintingPolicy printingPolicyForDecls(PrintingPolicy Base) {
   PrintingPolicy Policy(Base);
 
if (!HI.LocalScope.empty())
     HI.LocalScope.append("::");
 
   PrintingPolicy Policy = printingPolicyForDecls(Ctx.getPrintingPolicy());
   if (const NamedDecl *ND = llvm::dyn_cast<NamedDecl>(D)) {
     HI.Documentation = getDeclComment(Ctx, *ND);
     HI.Name = printName(Ctx, *ND);
   }
 
-  HI.Kind = indexSymbolKindToSymbolKind(index::getSymbolInfo(D).Kind);
+  HI.Kind = index::getSymbolInfo(D).Kind;
 
   // Fill in template params.
   if (const TemplateDecl *TD = D->getDescribedTemplate()) {
     HI.TemplateParameters =
         fetchTemplateParameters(TD->getTemplateParameters(), Policy);
     D = TD;
   } else if (const FunctionDecl *FD = D->getAsFunction()) {
     if (const auto FTD = FD->getDescribedTemplate()) {
HoverInfo getHoverContents(QualType T, const Decl *D, ASTContext &ASTCtx,
                                   const SymbolIndex *Index) {
   HoverInfo HI;
   llvm::raw_string_ostream OS(HI.Name);
   PrintingPolicy Policy = printingPolicyForDecls(ASTCtx.getPrintingPolicy());
   T.print(OS, Policy);
   OS.flush();
 
   if (D) {
-    HI.Kind = indexSymbolKindToSymbolKind(index::getSymbolInfo(D).Kind);
+    HI.Kind = index::getSymbolInfo(D).Kind;
     enhanceFromIndex(HI, D, Index);
   }
   return HI;
 }
 
 /// Generate a \p Hover object given the macro \p MacroDecl.
 HoverInfo getHoverContents(const DefinedMacro &Macro, ParsedAST &AST) {
   HoverInfo HI;
   SourceManager &SM = AST.getSourceManager();
   HI.Name = Macro.Name;
-  HI.Kind = indexSymbolKindToSymbolKind(
-      index::getSymbolInfoForMacro(*Macro.Info).Kind);
+  HI.Kind = index::SymbolKind::Macro;
   // FIXME: Populate documentation
   // FIXME: Pupulate parameters
 
   // Try to get the full definition, not just the name
   SourceLocation StartLoc = Macro.Info->getDefinitionLoc();
   SourceLocation EndLoc = Macro.Info->getDefinitionEndLoc();
   if (EndLoc.isValid()) {
     EndLoc = Lexer::getLocForEndOfToken(EndLoc, 0, SM, AST.getLangOpts());

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

const std::function<void(HoverInfo &)> ExpectedBuilder;
       // Global scope.
       {R"cpp(
           // Best foo ever.
           void [[fo^o]]() {}
           )cpp",
        [](HoverInfo &HI) {
          HI.NamespaceScope = "";
          HI.Name = "foo";
-         HI.Kind = SymbolKind::Function;
+         HI.Kind = index::SymbolKind::Function;
          HI.Documentation = "Best foo ever.";
          HI.Definition = "void foo()";
          HI.ReturnType = "void";
          HI.Type = "void ()";
          HI.Parameters.emplace();
        }},
       // Inside namespace
       {R"cpp(
           namespace ns1 { namespace ns2 {
             /// Best foo ever.
             void [[fo^o]]() {}
           }}
           )cpp",
        [](HoverInfo &HI) {
          HI.NamespaceScope = "ns1::ns2::";
          HI.Name = "foo";
-         HI.Kind = SymbolKind::Function;
+         HI.Kind = index::SymbolKind::Function;
          HI.Documentation = "Best foo ever.";
          HI.Definition = "void foo()";
          HI.ReturnType = "void";
          HI.Type = "void ()";
          HI.Parameters.emplace();
        }},
       // Field
       {R"cpp(
           namespace ns1 { namespace ns2 {
             struct Foo {
               int [[b^ar]];
             };
           }}
           )cpp",
        [](HoverInfo &HI) {
          HI.NamespaceScope = "ns1::ns2::";
          HI.LocalScope = "Foo::";
          HI.Name = "bar";
-         HI.Kind = SymbolKind::Field;
+         HI.Kind = index::SymbolKind::Field;
          HI.Definition = "int bar";
          HI.Type = "int";
        }},
       // Local to class method.
       {R"cpp(
           namespace ns1 { namespace ns2 {
             struct Foo {
               void foo() {
                 int [[b^ar]];
               }
             };
           }}
           )cpp",
        [](HoverInfo &HI) {
          HI.NamespaceScope = "ns1::ns2::";
          HI.LocalScope = "Foo::foo::";
          HI.Name = "bar";
-         HI.Kind = SymbolKind::Variable;
+         HI.Kind = index::SymbolKind::Variable;
          HI.Definition = "int bar";
          HI.Type = "int";
        }},
       // Anon namespace and local scope.
       {R"cpp(
           namespace ns1 { namespace {
             struct {
               int [[b^ar]];
             } T;
           }}
           )cpp",
        [](HoverInfo &HI) {
          HI.NamespaceScope = "ns1::(anonymous)::";
          HI.LocalScope = "(anonymous struct)::";
          HI.Name = "bar";
-         HI.Kind = SymbolKind::Field;
+         HI.Kind = index::SymbolKind::Field;
          HI.Definition = "int bar";
          HI.Type = "int";
        }},
       // Variable with template type
       {R"cpp(
           template <typename T, class... Ts> class Foo { public: Foo(int); };
           Foo<int, char, bool> [[fo^o]] = Foo<int, char, bool>(5);
           )cpp",
        [](HoverInfo &HI) {
          HI.NamespaceScope = "";
          HI.Name = "foo";
-         HI.Kind = SymbolKind::Variable;
+         HI.Kind = index::SymbolKind::Variable;
          HI.Definition = "Foo<int, char, bool> foo = Foo<int, char, bool>(5)";
          HI.Type = "Foo<int, char, bool>";
        }},
       // Implicit template instantiation
       {R"cpp(
           template <typename T> class vector{};
           [[vec^tor]]<int> foo;
           )cpp",
        [](HoverInfo &HI) {
          HI.NamespaceScope = "";
          HI.Name = "vector";
-         HI.Kind = SymbolKind::Class;
+         HI.Kind = index::SymbolKind::Class;
          HI.Definition = "template <typename T> class vector {}";
          HI.TemplateParameters = {
              {std::string("typename"), std::string("T"), llvm::None},
          };
        }},
       // Class template
       {R"cpp(
           template <template<typename, bool...> class C,
                     typename = char,
                     int = 0,
                     bool Q = false,
                     class... Ts> class Foo {};
           template <template<typename, bool...> class T>
           [[F^oo]]<T> foo;
           )cpp",
        [](HoverInfo &HI) {
          HI.NamespaceScope = "";
          HI.Name = "Foo";
-         HI.Kind = SymbolKind::Class;
+         HI.Kind = index::SymbolKind::Class;
          HI.Definition =
              R"cpp(template <template <typename, bool...> class C, typename = char, int = 0,
           bool Q = false, class... Ts>
 class Foo {})cpp";
          HI.TemplateParameters = {
              {std::string("template <typename, bool...> class"),
               std::string("C"), llvm::None},
              {std::string("typename"), llvm::None, std::string("char")},
class Foo {})cpp";
 
           void bar() {
             [[fo^o]]<Foo>();
           }
           )cpp",
        [](HoverInfo &HI) {
          HI.NamespaceScope = "";
          HI.Name = "foo";
-         HI.Kind = SymbolKind::Function;
+         HI.Kind = index::SymbolKind::Function;
          HI.Definition =
              R"cpp(template <template <typename, bool...> class C, typename = char, int = 0,
           bool Q = false, class... Ts>
 void foo())cpp";
          HI.ReturnType = "void";
          HI.Type = "void ()";
          HI.Parameters.emplace();
          HI.TemplateParameters = {
void foo())cpp";
 
           void bar() {
             [[fo^o]](3);
           }
           )cpp",
        [](HoverInfo &HI) {
          HI.NamespaceScope = "";
          HI.Name = "foo";
-         HI.Kind = SymbolKind::Function;
+         HI.Kind = index::SymbolKind::Function;
          HI.Definition = "Foo<bool, true, false> foo(int, bool T = false)";
          HI.ReturnType = "Foo<bool, true, false>";
          HI.Type = "Foo<bool, true, false> (int, bool)";
          HI.Parameters = {
              {std::string("int"), llvm::None, llvm::None},
              {std::string("bool"), std::string("T"), std::string("false")},
          };
        }},
       // Pointers to lambdas
       {R"cpp(
         void foo() {
           auto lamb = [](int T, bool B) -> bool { return T && B; };
           auto *b = &lamb;
           auto *[[^c]] = &b;
         }
         )cpp",
        [](HoverInfo &HI) {
          HI.NamespaceScope = "";
          HI.LocalScope = "foo::";
          HI.Name = "c";
-         HI.Kind = SymbolKind::Variable;
+         HI.Kind = index::SymbolKind::Variable;
          HI.Definition = "auto *c = &b";
          HI.Type = "class (lambda) **";
          HI.ReturnType = "bool";
          HI.Parameters = {
              {std::string("int"), std::string("T"), llvm::None},
              {std::string("bool"), std::string("B"), llvm::None},
          };
          return HI;
        }},
       // Lambda parameter with decltype reference
       {R"cpp(
         auto lamb = [](int T, bool B) -> bool { return T && B; };
         void foo(decltype(lamb)& bar) {
           [[ba^r]](0, false);
         }
         )cpp",
        [](HoverInfo &HI) {
          HI.NamespaceScope = "";
          HI.LocalScope = "foo::";
          HI.Name = "bar";
-         HI.Kind = SymbolKind::Variable;
+         HI.Kind = index::SymbolKind::Parameter;
          HI.Definition = "decltype(lamb) &bar";
          HI.Type = "decltype(lamb) &";
          HI.ReturnType = "bool";
          HI.Parameters = {
              {std::string("int"), std::string("T"), llvm::None},
              {std::string("bool"), std::string("B"), llvm::None},
          };
          return HI;
        }},
       // Lambda parameter with decltype
       {R"cpp(
         auto lamb = [](int T, bool B) -> bool { return T && B; };
         void foo(decltype(lamb) bar) {
           [[ba^r]](0, false);
         }
         )cpp",
        [](HoverInfo &HI) {
          HI.NamespaceScope = "";
          HI.LocalScope = "foo::";
          HI.Name = "bar";
-         HI.Kind = SymbolKind::Variable;
+         HI.Kind = index::SymbolKind::Parameter;
          HI.Definition = "decltype(lamb) bar";
          HI.Type = "class (lambda)";
          HI.ReturnType = "bool";
          HI.Parameters = {
              {std::string("int"), std::string("T"), llvm::None},
              {std::string("bool"), std::string("B"), llvm::None},
          };
          HI.Value = "false";
          return HI;
        }},
       // Lambda variable
       {R"cpp(
         void foo() {
           int bar = 5;
           auto lamb = [&bar](int T, bool B) -> bool { return T && B && bar; };
           bool res = [[lam^b]](bar, false);
         }
         )cpp",
        [](HoverInfo &HI) {
          HI.NamespaceScope = "";
          HI.LocalScope = "foo::";
          HI.Name = "lamb";
-         HI.Kind = SymbolKind::Variable;
+         HI.Kind = index::SymbolKind::Variable;
          HI.Definition = "auto lamb = [&bar](int T, bool B) -> bool {}";
          HI.Type = "class (lambda)";
          HI.ReturnType = "bool";
          HI.Parameters = {
              {std::string("int"), std::string("T"), llvm::None},
              {std::string("bool"), std::string("B"), llvm::None},
          };
          return HI;
        }},
       // Local variable in lambda
       {R"cpp(
         void foo() {
           auto lamb = []{int [[te^st]];};
         }
         )cpp",
        [](HoverInfo &HI) {
          HI.NamespaceScope = "";
          HI.LocalScope = "foo::(anonymous class)::operator()::";
          HI.Name = "test";
-         HI.Kind = SymbolKind::Variable;
+         HI.Kind = index::SymbolKind::Variable;
          HI.Definition = "int test";
          HI.Type = "int";
        }},
       // Partially-specialized class template. (formerly type-parameter-0-0)
       {R"cpp(
         template <typename T> class X;
         template <typename T> class [[^X]]<T*> {};
         )cpp",
        [](HoverInfo &HI) {
          HI.Name = "X<T *>";
          HI.NamespaceScope = "";
-         HI.Kind = SymbolKind::Class;
+         HI.Kind = index::SymbolKind::Class;
          HI.Definition = "template <typename T> class X<T *> {}";
        }},
       // Constructor of partially-specialized class template
       {R"cpp(
           template<typename, typename=void> struct X;
           template<typename T> struct X<T*>{ [[^X]](); };
           )cpp",
        [](HoverInfo &HI) {
          HI.NamespaceScope = "";
          HI.Name = "X";
          HI.LocalScope = "X<T *>::"; // FIXME: X<T *, void>::
-         HI.Kind = SymbolKind::Constructor;
+         HI.Kind = index::SymbolKind::Constructor;
          HI.ReturnType = "X<T *>";
          HI.Definition = "X()";
          HI.Parameters.emplace();
        }},
       {"class X { [[^~]]X(); };", // FIXME: Should be [[~X]]()
        [](HoverInfo &HI) {
          HI.NamespaceScope = "";
          HI.Name = "~X";
          HI.LocalScope = "X::";
-         HI.Kind = SymbolKind::Constructor;
+         HI.Kind = index::SymbolKind::Destructor;
          HI.ReturnType = "void";
          HI.Definition = "~X()";
          HI.Parameters.emplace();
        }},
 
       // auto on lambda
       {R"cpp(
         void foo() {
           [[au^to]] lamb = []{};
         }
         )cpp",
        [](HoverInfo &HI) {
          HI.Name = "class (lambda)";
-         HI.Kind = SymbolKind::Class;
+         HI.Kind = index::SymbolKind::Class;
        }},
       // auto on template instantiation
       {R"cpp(
         template<typename T> class Foo{};
         void foo() {
           [[au^to]] x = Foo<int>();
         }
         )cpp",
        [](HoverInfo &HI) {
          HI.Name = "class Foo<int>";
-         HI.Kind = SymbolKind::Class;
+         HI.Kind = index::SymbolKind::Class;
        }},
       // auto on specialized template
       {R"cpp(
         template<typename T> class Foo{};
         template<> class Foo<int>{};
         void foo() {
           [[au^to]] x = Foo<int>();
         }
         )cpp",
        [](HoverInfo &HI) {
          HI.Name = "class Foo<int>";
-         HI.Kind = SymbolKind::Class;
+         HI.Kind = index::SymbolKind::Class;
        }},
 
       // macro
       {R"cpp(
         // Best MACRO ever.
         #define MACRO(x,y,z) void foo(x, y, z);
         [[MAC^RO]](int, double d, bool z = false);
         )cpp",
        [](HoverInfo &HI) {
-         HI.Name = "MACRO", HI.Kind = SymbolKind::String,
+         HI.Name = "MACRO", HI.Kind = index::SymbolKind::Macro,
          HI.Definition = "#define MACRO(x, y, z) void foo(x, y, z);";
        }},
 
       // constexprs
       {R"cpp(
         constexpr int add(int a, int b) { return a + b; }
         int [[b^ar]] = add(1, 2);
         )cpp",
        [](HoverInfo &HI) {
          HI.Name = "bar";
          HI.Definition = "int bar = add(1, 2)";
-         HI.Kind = SymbolKind::Variable;
+         HI.Kind = index::SymbolKind::Variable;
          HI.Type = "int";
          HI.NamespaceScope = "";
          HI.Value = "3";
        }},
       {R"cpp(
         int [[b^ar]] = sizeof(char);
         )cpp",
        [](HoverInfo &HI) {
          HI.Name = "bar";
          HI.Definition = "int bar = sizeof(char)";
-         HI.Kind = SymbolKind::Variable;
+         HI.Kind = index::SymbolKind::Variable;
          HI.Type = "int";
          HI.NamespaceScope = "";
          HI.Value = "1";
        }},
       {R"cpp(
         template<int a, int b> struct Add {
           static constexpr int result = a + b;
         };
         int [[ba^r]] = Add<1, 2>::result;
         )cpp",
        [](HoverInfo &HI) {
          HI.Name = "bar";
          HI.Definition = "int bar = Add<1, 2>::result";
-         HI.Kind = SymbolKind::Variable;
+         HI.Kind = index::SymbolKind::Variable;
          HI.Type = "int";
          HI.NamespaceScope = "";
          HI.Value = "3";
        }},
       {R"cpp(
         enum Color { RED, GREEN, };
         Color x = [[GR^EEN]];
        )cpp",
        [](HoverInfo &HI) {
          HI.Name = "GREEN";
          HI.NamespaceScope = "";
          HI.LocalScope = "Color::";
          HI.Definition = "GREEN";
-         HI.Kind = SymbolKind::EnumMember;
+         HI.Kind = index::SymbolKind::EnumConstant;
          HI.Type = "enum Color";
          HI.Value = "1"; // Numeric when hovering on the enumerator name.
        }},
       {R"cpp(
         enum Color { RED, GREEN, };
         Color x = GREEN;
         Color y = [[^x]];
        )cpp",
        [](HoverInfo &HI) {
          HI.Name = "x";
          HI.NamespaceScope = "";
          HI.Definition = "enum Color x = GREEN";
-         HI.Kind = SymbolKind::Variable;
+         HI.Kind = index::SymbolKind::Variable;
          HI.Type = "enum Color";
          HI.Value = "GREEN (1)"; // Symbolic when hovering on an expression.
        }},
       // FIXME: We should use the Decl referenced, even if from an implicit
       // instantiation. Then the scope would be Add<1, 2>.
       {R"cpp(
         template<int a, int b> struct Add {
           static constexpr int result = a + b;
         };
         int bar = Add<1, 2>::[[resu^lt]];
         )cpp",
        [](HoverInfo &HI) {
          HI.Name = "result";
          HI.Definition = "static constexpr int result = a + b";
-         HI.Kind = SymbolKind::Property;
+         HI.Kind = index::SymbolKind::StaticProperty;
          HI.Type = "const int";
          HI.NamespaceScope = "";
          HI.LocalScope = "Add<a, b>::";
          HI.Value = "3";
        }},
       {R"cpp(
         constexpr int answer() { return 40 + 2; }
         int x = [[ans^wer]]();
         )cpp",
        [](HoverInfo &HI) {
          HI.Name = "answer";
          HI.Definition = "constexpr int answer()";
-         HI.Kind = SymbolKind::Function;
+         HI.Kind = index::SymbolKind::Function;
          HI.Type = "int ()";
          HI.ReturnType = "int";
          HI.Parameters.emplace();
          HI.NamespaceScope = "";
          HI.Value = "42";
        }},
       {R"cpp(
         const char *[[ba^r]] = "1234";
         )cpp",
        [](HoverInfo &HI) {
          HI.Name = "bar";
          HI.Definition = "const char *bar = \"1234\"";
-         HI.Kind = SymbolKind::Variable;
+         HI.Kind = index::SymbolKind::Variable;
          HI.Type = "const char *";
          HI.NamespaceScope = "";
          HI.Value = "&\"1234\"[0]";
        }},
   };
   for (const auto &Case : Cases) {
     SCOPED_TRACE(Case.Code);