[clangd] Always desugar type aliases in hover

[kadircet]

Summary

The alias itself is already included in the definition section of the
hover (it's printed as spelled in source code). So it doesn't provide any value
when we print the aliases as-is.
Fixes https://github.com/clangd/clangd/issues/1134.

[ilya-biryukov]

LGTM. Please take a look the NIT about landing this as two commits.

clang-tools-extra/clangd/Hover.cpp

581

NIT: maybe use auto& here?
The name of the type is mentioned directly in the initialization.

626–627

NIT: could you please land the refactoring with ASTContext and this change separately?
It was a bit hard to find the relevant change for me, I suspect reading the git history might also be problematic in the future.

[kadircet]

• Leave the Ctx refactoring out of the patch.

clang-tools-extra/clangd/Hover.cpp

std::string synthesizeDocumentation(const NamedDecl *ND) {
   return "";
 }
 
 /// Generate a \p Hover object given the declaration \p D.
 HoverInfo getHoverContents(const NamedDecl *D, const PrintingPolicy &PP,
                            const SymbolIndex *Index,
                            const syntax::TokenBuffer &TB) {
   HoverInfo HI;
   const ASTContext &Ctx = D->getASTContext();
 
   HI.AccessSpecifier = getAccessSpelling(D->getAccess()).str();
   HI.NamespaceScope = getNamespaceScope(D);
   if (!HI.NamespaceScope->empty())
     HI.NamespaceScope->append("::");
   HI.LocalScope = getLocalScope(D);
   if (!HI.LocalScope.empty())
     HI.LocalScope.append("::");
HoverInfo getHoverContents(const NamedDecl *D, const PrintingPolicy &PP,
   else if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(D))
     HI.Type = TTP->wasDeclaredWithTypename() ? "typename" : "class";
   else if (const auto *TTP = dyn_cast<TemplateTemplateParmDecl>(D))
     HI.Type = printType(TTP, PP);
   else if (const auto *VT = dyn_cast<VarTemplateDecl>(D))
     HI.Type =
         printType(VT->getTemplatedDecl()->getType(), VT->getASTContext(), PP);
   else if (const auto *TN = dyn_cast<TypedefNameDecl>(D))
-    HI.Type = printType(TN->getUnderlyingType(), TN->getASTContext(), PP);
+    HI.Type = printType(TN->getUnderlyingType().getDesugaredType(Ctx),
+                        TN->getASTContext(), PP);
   else if (const auto *TAT = dyn_cast<TypeAliasTemplateDecl>(D))
     HI.Type = printType(TAT->getTemplatedDecl()->getUnderlyingType(),
                         TAT->getASTContext(), PP);
 
   // Fill in value with evaluated initializer if possible.
   if (const auto *Var = dyn_cast<VarDecl>(D)) {
     if (const Expr *Init = Var->getInit())
       HI.Value = printExprValue(Init, Ctx);

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

TEST(Hover, HideBigInitializers) {
 
   TestTU TU = TestTU::withCode(T.code());
   auto AST = TU.build();
   auto H = getHover(AST, T.point(), format::getLLVMStyle(), nullptr);
 
   ASSERT_TRUE(H);
   EXPECT_EQ(H->Definition, "int arr[]");
 }
+
+TEST(Hover, Typedefs) {
+  Annotations T(R"cpp(
+  template <bool X, typename T, typename F>
+  struct cond { using type = T; };
+  template <typename T, typename F>
+  struct cond<false, T, F> { using type = F; };
+
+  template <bool X, typename T, typename F>
+  using type = typename cond<X, T, F>::type;
+
+  void foo() {
+    using f^oo = type<true, int, double>;
+  }
+  )cpp");
+
+  TestTU TU = TestTU::withCode(T.code());
+  auto AST = TU.build();
+  auto H = getHover(AST, T.point(), format::getLLVMStyle(), nullptr);
+
+  ASSERT_TRUE(H && H->Type);
+  EXPECT_EQ(H->Type->Type, "int");
+  EXPECT_EQ(H->Definition, "using foo = type<true, int, double>");
+}
 } // namespace
 } // namespace clangd
 } // namespace clang