[clangd] Add desugared type to hover

[lh123]

Summary

Add desugared type to hover when the desugared type and the pretty-printed type are different.

c++
template<typename T>
struct TestHover {
  using Type = T;
};

int main() {
  TestHover<int>::Type a;
}

---

variable a

Type: TestHover<int>::Type (aka 'int')

[lh123]

add testcase

[lh123]

format code and add testcase for template.

[lh123]

Related discussions: D72498

[sammccall]

I agree we often show the wrong amount of sugar, and with the thrust of this patch.

Some pareto-improments are possible with a single type, but we can't solve this problem satisfactorily:

• the right amount of sugar can vary for the same code pattern (vector<T>::iterator vs cast_retty<x, y>::ret_type)
• it can depend on what the reader's context is, which we can't know

However I think desugaring all the way to the canonical type, and showing it whenever the strings are not exactly equal, are too blunt as policies.
A similar situation in clang is deciding when to print "aka" in a diagnostic, and what the AKA type should be. The code controlling that is in Desugar() in clang/lib/AST/ASTDiagnostic.cpp. It's handled pretty carefully, and in a place that's likely to be well-maintained.
(It's also wrapped in functions that process a whole diagnostic to take into account multiple types that appear, which we can ignore).

I'd suggest we expose that function from ASTDiagnostic.h and use it for this purpose.

clang-tools-extra/clangd/Hover.cpp

708–711

This seems like a pretty important case to handle.
A wrinkle is that this gets treated as C++ code (e.g. client-side syntax highlighted).

So we might need something like

int64_t
// aka
long long

or

int64_t
// aka: long long

1095

I'm not sure that quoting the aka type when we don't quote the original is appropriate

1149

I think printing two types here is too disruptive to the reading flow, this is a parenthetical already

clang-tools-extra/clangd/Hover.h

43

instead of these ad-hoc pairs, I'd suggest introducing a common struct like:

Optional<PrintedType> Type;

struct PrintedType {
  std::string Type;
  Optional<std::string> AKA;
};

that way producing function like printType and formatting functions that produce "foo (aka bar)" can more simply be shared between instances of this pattern

[lh123]

address comment.

[lh123]

fix some bug.

[lh123]

1. rename CanType to DesugaredTy.
2. fix some bug in compare PrintedType.

[lh123]

handle TypeAliasTemplateDecl.

[lh123]

rename TTD to TAT.

[lh123]

Move some desugared type to Definition.

[lh123]

clang-tools-extra/clangd/Hover.cpp

708–711

It seems we can't do this, vscode always display

int64_t
// aka: long long

as

int64_t
    // aka: long long

So I change it to int64_t // aka: long long

[lh123]

clang-tools-extra/clangd/Hover.cpp

166

It seems we lost namespace qualifiers.
It always display std::string as basic_string<char>

[lh123]

clang-tools-extra/clangd/Hover.cpp

166

Should we set FullyQualifiedName printing policy for DesugaredTy.

[lh123]

clang-tools-extra/clangd/Hover.cpp

166

Sometimes we need to distinguish certain types with the same name based on the fully qualified name.
eg.

namespace custom {
template <typename T> struct vector {};
} // namespace custom

void code() {
  custom::vector<size_t> a;
  std::vector<size_t> b;
}

Currently, both a and b show vector<unsigned long>.

[sammccall]

This looks pretty good in terms of behavior, some impl comments but we should land this.

My main remaining concern is just that this will trigger too often when there's no confusion over types, and clutter the display.
Some common cases I'm worried about:

• std::string -> basic_string<char>. Maybe we should special-case this to hide the aka?
• int64_t vs long long et al. I have no idea what to do about this.

@kadircet hopefully has thoughts on what hover should look like

clang-tools-extra/clangd/Hover.cpp

142

nit: ASTCtx or Ctx to distinguish from clangd::Context

149

nit: declare a HoverInfo::PrintedType Result and write directly into it instead of these partial variables?

160

prefer printing into the same string rather than copying into a new one

166

I'd lean against setting FullyQualifiedName for the AKA type. Clang doesn't for diagnostics (I see 'std::string' aka 'basic_string<char>').
It is more specific and adds verbosity. It should be very rare that it is the only way to find things out, e.g. in your example the *original* types would be different as they include the namespace as spelled in the code.

166

The e.g. "class " prefix isn't needed in the a.k.a, so no need to copy strings for that.

(and in fact I'm not sure it's possible to hit an AKA when this string is nonempty)

189

How strongly do you feel about handling this case?

This code is much more surprising than the previous version and maybe we can find a simpler way to express it, but all of this only matters if we have a template-template-paramater with a non-type-template-parameter with nontrivial sugar which obscures meaning.

That seems pretty unlikely to ever come up, and if it does I'm not sure repeating the whole TTP is a great experience.

I'd suggest just dropping the possibility of an AKA type here until someone runs into a case where it's a real issue...

689

HI.Definition = std::move(PType.Type)

689

this formatting of the definition appears twice, pull out a function? string typeAsDefinition(PrintedType) or so

1093

appendCode(llvm::to_string(ReturnType))

(from ScopedPrinter.h)

1271

Hmm, this seems to render as:

std::string Foo = "" (aka basic_string<char>)

it's not *completely* clear what the aka refers to.
I don't have a better solution, though.
@kadircet any opinions here?

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

48

you could reduce the noise here by giving PrintedType a constructor from char* or so...

clang/include/clang/AST/ASTDiagnostic.h

38

when exposing this, we should probably give it a more specific name like desugarForDiagnostic, so it's not confused with the various QT->desugar() or getCanonicalType() type functions.

While renaming, it should start with a lowercase d.

[kadircet]

My main remaining concern is just that this will trigger too often when there's no confusion over types, and clutter the display.
Some common cases I'm worried about:

• std::string -> basic_string<char>. Maybe we should special-case this to hide the aka?
• int64_t vs long long et al. I have no idea what to do about this.

As discussed offline I share these concerns, and it's not the first time we're facing them. I am afraid that this might be disturbing for a good fraction of users if we don't polish it around common types.
A couple of suggestions I have (they don't necessarily need to land as part of this patch, but I think we should land some damage control mechanism before next release):

• Make AKA-printing completely optional, to give users a way out (while probably starting with off by default and experimenting for a while to see the most annoying cases and polishing them as needed)
• Have a list of user-configurable FQNs that AKA printing would be disabled for (and provide a good set of defaults inside clangd for STL)

clang-tools-extra/clangd/Hover.cpp

1271

i think it's attached to the type of the parameter, not it's name nor the initializer-expr. so I think we should move this closer to the type (i.e. std::string (aka basic_sting<char>) Foo = "", basically llvm::toString(P.Type) ?)

[lh123]

address comment.

[lh123]

format code.

[lh123]

format again.

[lh123]

rebase to head.

[sammccall]

Thank you! (& Sorry for the delay, have been sick)
LG with the understanding we may have to iterate on behavior/configurability.

As noted below I'd suggest either disabling aka for params, or reverting to the previous version, but I don't feel strongly.

clang-tools-extra/clangd/Hover.cpp

1265

this can just be << *P.Type, skipping the temporary string

1271

i think it's attached to the type of the parameter

This is logically correct but I think it's harder to read. This puts text in the middle of code, in a way that doesn't seem obvious to me: parens mean several things in C++ and it may be hard to recognize this means none of them.

Worst case is we have function types: word(*)() (aka long(*)()) x = nullptr

It also disrupts the reading flow in the case where the aka is *not* needed for understanding.
I think overall the previous version was better, though not great.

I'm tempted to say we should scope down this patch further until we have a better feel for how it behaves, i.e. exclude param types from aka for now. Param types are less obviously useful to disambiguate than result types. (e.g. because in most cases you can hover over the input expression).

[sammccall]

In D114522#3156167, @kadircet wrote:

Have a list of user-configurable FQNs that AKA printing would be disabled for (and provide a good set of defaults inside clangd for STL)

BTW this seems hard to implement well without invasive changes to the desugar logic.

Nontrivial case: the list is {std::string}, the type is std::string*.

Pathological case: the list is {std::string}, and the type is pair<std::string*, size_t>. Desugar yields pair<basic_string<char>*, long long>, desired output is pair<std::string*, long long>.
desugarForDiagnostic needs to exclude the first TP from desugaring based on it matching a string, but we don't stringify all the intermediate types.

[lh123]

clang-tools-extra/clangd/Hover.cpp

1271

I'm tempted to say we should scope down this patch further until we have a better feel for how it behaves, i.e. exclude param types from aka for now. Param types are less obviously useful to disambiguate than result types. (e.g. because in most cases you can hover over the input expression).

I‘d like to keep the a.k.a type for parameter. because:

1. sometime we pass literal (or null pointer) as parameter, but clang doesn't support hover on literal. eg:

using mint = int;
void foo(mint *);
void code() {
    foo(nullptr); // hover over foo, we can get 'mint * (aka int *)'
}

2. It may be useful when making function calls, although it does not work well when the function is overloaded.(add a.k.a type to signature help?) eg:

using mint = int;
void foo(mint *);
void code() {
    foo(); // hover on foo, we can get 'mint * (aka int *)'
}

I think overall the previous version was better, though not great.

Agree with that, it seems that putting a.k.a in the middle of the code makes the hover look bad based on my recent use

[lh123]

clang-tools-extra/clangd/Hover.cpp

1271

It is also useful when pass function calling as parameters.

struct Test {
  Test(int);
};
using Alias = Test;

int foo();
void bar(Alias);

void code() {
    bar(foo()); // Hover over bar, we can know that 'int' is implicitly converted to 'Test'
}

clang-tools-extra/clangd/Hover.h

 namespace clang {
 namespace clangd {
 
 /// Contains detailed information about a Symbol. Especially useful when
 /// generating hover responses. It can be rendered as a hover panel, or
 /// embedding clients can use the structured information to provide their own
 /// UI.
 struct HoverInfo {
+  /// Contains pretty-printed type and desugared type
+  struct PrintedType {
+    /// Pretty-printed type
+    std::string Type;
+    /// Desugared type
+    Optional<std::string> AKA;
+  };
+
   /// 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
+    /// The printable parameter type, e.g. "int", or "typename" (in
     /// TemplateParameters), might be None for macro parameters.
-    llvm::Optional<std::string> Type;
+    llvm::Optional<PrintedType> 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::
struct HoverInfo {
   index::SymbolKind Kind = index::SymbolKind::Unknown;
   std::string Documentation;
   /// Source code containing the definition of the symbol.
   std::string Definition;
   const char *DefinitionLanguage = "cpp";
   /// Access specifier for declarations inside class/struct/unions, empty for
   /// others.
   std::string AccessSpecifier;
-  /// Pretty-printed variable type.
+  /// Printable variable type.
   /// Set only for variables.
-  llvm::Optional<std::string> Type;
+  llvm::Optional<PrintedType> Type;
   /// Set for functions and lambdas.
-  llvm::Optional<std::string> ReturnType;
+  llvm::Optional<PrintedType> ReturnType;
   /// Set for functions, lambdas and macros with parameters.
   llvm::Optional<std::vector<Param>> Parameters;
   /// Set for all templates(function, class, variable).
   llvm::Optional<std::vector<Param>> TemplateParameters;
   /// Contains the evaluated value of the symbol if available.
   llvm::Optional<std::string> Value;
   /// Contains the byte-size of fields and types where it's interesting.
   llvm::Optional<uint64_t> Size;
struct HoverInfo {
   };
   // Set only if CalleeArgInfo is set.
   llvm::Optional<PassType> CallPassType;
 
   /// Produce a user-readable information.
   markup::Document present() const;
 };
 
+inline bool operator==(const HoverInfo::PrintedType &LHS,
+                       const HoverInfo::PrintedType &RHS) {
+  return std::tie(LHS.Type, LHS.AKA) == std::tie(RHS.Type, RHS.AKA);
+}
+
 inline bool operator==(const HoverInfo::PassType &LHS,
                        const HoverInfo::PassType &RHS) {
   return std::tie(LHS.PassBy, LHS.Converted) ==
          std::tie(RHS.PassBy, RHS.Converted);
 }
 
 // Try to infer structure of a documentation comment (e.g. line breaks).
 // FIXME: move to another file so CodeComplete doesn't depend on Hover.
 void parseDocumentation(llvm::StringRef Input, markup::Document &Output);
 
+llvm::raw_ostream &operator<<(llvm::raw_ostream &,
+                              const HoverInfo::PrintedType &);
 llvm::raw_ostream &operator<<(llvm::raw_ostream &, const HoverInfo::Param &);
 inline bool operator==(const HoverInfo::Param &LHS,
                        const HoverInfo::Param &RHS) {
   return std::tie(LHS.Type, LHS.Name, LHS.Default) ==
          std::tie(RHS.Type, RHS.Name, RHS.Default);
 }
 
 /// Get the hover information when hovering at \p Pos.
 llvm::Optional<HoverInfo> getHover(ParsedAST &AST, Position Pos,
                                    format::FormatStyle Style,
                                    const SymbolIndex *Index);
 
 } // namespace clangd
 } // namespace clang
 
 #endif

clang-tools-extra/clangd/Hover.cpp

 #include "FindTarget.h"
 #include "ParsedAST.h"
 #include "Selection.h"
 #include "SourceCode.h"
 #include "index/SymbolCollector.h"
 #include "support/Logger.h"
 #include "support/Markup.h"
 #include "clang/AST/ASTContext.h"
+#include "clang/AST/ASTDiagnostic.h"
 #include "clang/AST/ASTTypeTraits.h"
 #include "clang/AST/Attr.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/Expr.h"

 
 const char *getMarkdownLanguage(const ASTContext &Ctx) {
   const auto &LangOpts = Ctx.getLangOpts();
   if (LangOpts.ObjC && LangOpts.CPlusPlus)
     return "objective-cpp";
   return LangOpts.ObjC ? "objective-c" : "cpp";
 }
 
-std::string printType(QualType QT, const PrintingPolicy &PP) {
+HoverInfo::PrintedType printType(QualType QT, ASTContext &Context,
+                                 const PrintingPolicy &PP) {
   // TypePrinter doesn't resolve decltypes, so resolve them here.
   // FIXME: This doesn't handle composite types that contain a decltype in them.
   // We should rather have a printing policy for that.
   while (!QT.isNull() && QT->isDecltypeType())
     QT = QT->getAs<DecltypeType>()->getUnderlyingType();
   std::string Result;
   llvm::raw_string_ostream OS(Result);
   // Special case: if the outer type is a tag type without qualifiers, then
   // include the tag for extra clarity.
   // This isn't very idiomatic, so don't attempt it for complex cases, including
   // pointers/references, template specializations, etc.
   if (!QT.isNull() && !QT.hasQualifiers() && PP.SuppressTagKeyword) {
     if (auto *TT = llvm::dyn_cast<TagType>(QT.getTypePtr()))
       OS << TT->getDecl()->getKindName() << " ";
   }
   OS.flush();
-  QT.print(OS, PP);
-  return Result;
+  std::string Type = Result + QT.getAsString(PP);
+  llvm::Optional<std::string> AKA;
+  if (!QT.isNull()) {
+    bool ShouldAKA = false;
+    QualType DesugaredTy = clang::Desugar(Context, QT, ShouldAKA);
+    if (ShouldAKA)
+      AKA = Result + DesugaredTy.getAsString(PP);
+  }
+  return {Type, AKA};
 }
 
-std::string printType(const TemplateTypeParmDecl *TTP) {
+HoverInfo::PrintedType printType(const TemplateTypeParmDecl *TTP) {
   std::string Res = TTP->wasDeclaredWithTypename() ? "typename" : "class";
   if (TTP->isParameterPack())
     Res += "...";
-  return Res;
+  return {Res, llvm::None};
 }
 
-std::string printType(const NonTypeTemplateParmDecl *NTTP,
+HoverInfo::PrintedType printType(const NonTypeTemplateParmDecl *NTTP,
                                  const PrintingPolicy &PP) {
-  std::string Res = printType(NTTP->getType(), PP);
-  if (NTTP->isParameterPack())
-    Res += "...";
-  return Res;
+  auto PrintedType = printType(NTTP->getType(), NTTP->getASTContext(), PP);
+  if (NTTP->isParameterPack()) {
+    PrintedType.Type += "...";
+    if (PrintedType.AKA)
+      *PrintedType.AKA += "...";
+  }
+  return PrintedType;
 }
 
-std::string printType(const TemplateTemplateParmDecl *TTP,
+HoverInfo::PrintedType printType(const TemplateTemplateParmDecl *TTP,
                                  const PrintingPolicy &PP) {
-  std::string Res;
-  llvm::raw_string_ostream OS(Res);
-  OS << "template <";
-  llvm::StringRef Sep = "";
+  bool ShouldAKA = false;
+  llvm::SmallVector<std::string, 10> TypeParams;
+  llvm::SmallVector<std::string, 10> AKATypeParams;
   for (const Decl *Param : *TTP->getTemplateParameters()) {
-    OS << Sep;
-    Sep = ", ";
+    llvm::Optional<HoverInfo::PrintedType> PType;
     if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(Param))
-      OS << printType(TTP);
+      PType = printType(TTP);
     else if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Param))
-      OS << printType(NTTP, PP);
+      PType = printType(NTTP, PP);
     else if (const auto *TTPD = dyn_cast<TemplateTemplateParmDecl>(Param))
-      OS << printType(TTPD, PP);
+      PType = printType(TTPD, PP);
+    if (!PType)
+      continue;
+    TypeParams.push_back(PType->Type);
+    if (PType->AKA) {
+      ShouldAKA = true;
+      AKATypeParams.push_back(*PType->AKA);
+    } else
+      AKATypeParams.push_back(PType->Type);
   }
   // FIXME: TemplateTemplateParameter doesn't store the info on whether this
   // param was a "typename" or "class".
-  OS << "> class";
-  return OS.str();
+  const char *FMT = "template <{0}> class";
+  std::string Type = llvm::formatv(FMT, llvm::join(TypeParams, ", "));
+  llvm::Optional<std::string> AKA;
+  if (ShouldAKA)
+    AKA = llvm::formatv(FMT, llvm::join(AKATypeParams, ", "));
+  return {Type, AKA};
 }
 
 std::vector<HoverInfo::Param>
 fetchTemplateParameters(const TemplateParameterList *Params,
                         const PrintingPolicy &PP) {
   assert(Params);
   std::vector<HoverInfo::Param> TempParameters;
 
if (!PVD->hasDefaultArg() || PVD->hasUnparsedDefaultArg())
     return nullptr;
   return PVD->hasUninstantiatedDefaultArg() ? PVD->getUninstantiatedDefaultArg()
                                             : PVD->getDefaultArg();
 }
 
 HoverInfo::Param toHoverInfoParam(const ParmVarDecl *PVD,
                                   const PrintingPolicy &PP) {
   HoverInfo::Param Out;
-  Out.Type = printType(PVD->getType(), PP);
+  Out.Type = printType(PVD->getType(), PVD->getASTContext(), PP);
   if (!PVD->getName().empty())
     Out.Name = PVD->getNameAsString();
   if (const Expr *DefArg = getDefaultArg(PVD)) {
     Out.Default.emplace();
     llvm::raw_string_ostream OS(*Out.Default);
     DefArg->printPretty(OS, nullptr, PP);
   }
   return Out;
void fillFunctionTypeAndParams(HoverInfo &HI, const Decl *D,
   // We don't want any type info, if name already contains it. This is true for
   // constructors/destructors and conversion operators.
   const auto NK = FD->getDeclName().getNameKind();
   if (NK == DeclarationName::CXXConstructorName ||
       NK == DeclarationName::CXXDestructorName ||
       NK == DeclarationName::CXXConversionFunctionName)
     return;
 
-  HI.ReturnType = printType(FD->getReturnType(), PP);
+  HI.ReturnType = printType(FD->getReturnType(), FD->getASTContext(), PP);
   QualType QT = FD->getType();
   if (const VarDecl *VD = llvm::dyn_cast<VarDecl>(D)) // Lambdas
     QT = VD->getType().getDesugaredType(D->getASTContext());
-  HI.Type = printType(QT, PP);
+  HI.Type = printType(QT, D->getASTContext(), PP);
   // FIXME: handle variadics.
 }
 
 // Non-negative numbers are printed using min digits
 // 0     => 0x0
 // 100   => 0x64
 // Negative numbers are sign-extended to 32/64 bits
 // -2    => 0xfffffffe
if (const auto *FTD = FD->getDescribedTemplate()) {
       D = FTD;
     }
   }
 
   // Fill in types and params.
   if (const FunctionDecl *FD = getUnderlyingFunction(D))
     fillFunctionTypeAndParams(HI, D, FD, PP);
   else if (const auto *VD = dyn_cast<ValueDecl>(D))
-    HI.Type = printType(VD->getType(), PP);
+    HI.Type = printType(VD->getType(), VD->getASTContext(), PP);
   else if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(D))
-    HI.Type = TTP->wasDeclaredWithTypename() ? "typename" : "class";
+    HI.Type = {TTP->wasDeclaredWithTypename() ? "typename" : "class",
+               llvm::None};
   else if (const auto *TTP = dyn_cast<TemplateTemplateParmDecl>(D))
     HI.Type = printType(TTP, PP);
+  else if (const auto *TN = dyn_cast<TypedefNameDecl>(D))
+    HI.Type = printType(TN->getUnderlyingType(), 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);
   } else if (const auto *ECD = dyn_cast<EnumConstantDecl>(D)) {
     // Dependent enums (e.g. nested in template classes) don't have values yet.
     if (!ECD->getType()->isDependentType())
       HI.Value = toString(ECD->getInitVal(), 10);
   }
-
   HI.Definition = printDefinition(D, PP);
   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();
llvm::Optional<HoverInfo> getThisExprHoverContents(const CXXThisExpr *CTE,
   // parsed as `InjectedClassNameType`, which will ouput template arguments
   // like "type-parameter-0-0". So we retrieve user written class type in this
   // case.
   QualType PrettyThisType = ASTCtx.getPointerType(
       QualType(ClassType.getTypePtr(), OriginThisType.getCVRQualifiers()));
 
   HoverInfo HI;
   HI.Name = "this";
-  HI.Definition = printType(PrettyThisType, PP);
+  auto PType = printType(PrettyThisType, ASTCtx, PP);
+  HI.Definition = llvm::formatv("{0}", PType.Type);
+  if (PType.AKA)
+    HI.Definition += llvm::formatv(" // aka: {0}", *PType.AKA);
   return HI;
 }
 
 /// Generate a HoverInfo object given the deduced type \p QT
 HoverInfo getDeducedTypeHoverContents(QualType QT, const syntax::Token &Tok,
                                       ASTContext &ASTCtx,
                                       const PrintingPolicy &PP,
                                       const SymbolIndex *Index) {
   HoverInfo HI;
   // FIXME: distinguish decltype(auto) vs decltype(expr)
   HI.Name = tok::getTokenName(Tok.kind());
   HI.Kind = index::SymbolKind::TypeAlias;
 
   if (QT->isUndeducedAutoType()) {
     HI.Definition = "/* not deduced */";
   } else {
-    HI.Definition = printType(QT, PP);
+    auto PType = printType(QT, ASTCtx, PP);
+    HI.Definition = llvm::formatv("{0}", PType.Type);
+    if (PType.AKA)
+      HI.Definition += llvm::formatv(" // aka: {0}", *PType.AKA);
 
     if (const auto *D = QT->getAsTagDecl()) {
       const auto *CommentD = getDeclForComment(D);
       HI.Documentation = getDeclComment(ASTCtx, *CommentD);
       enhanceFromIndex(HI, *CommentD, Index);
     }
   }
 
llvm::Optional<HoverInfo> getHoverContents(const Expr *E, ParsedAST &AST,
 
   HoverInfo HI;
   // For `this` expr we currently generate hover with pointee type.
   if (const CXXThisExpr *CTE = dyn_cast<CXXThisExpr>(E))
     return getThisExprHoverContents(CTE, AST.getASTContext(), PP);
   // For expressions we currently print the type and the value, iff it is
   // evaluatable.
   if (auto Val = printExprValue(E, AST.getASTContext())) {
-    HI.Type = printType(E->getType(), PP);
+    HI.Type = printType(E->getType(), AST.getASTContext(), PP);
     HI.Value = *Val;
     HI.Name = std::string(getNameForExpr(E));
     return HI;
   }
   return llvm::None;
 }
 
 // Generates hover info for attributes.
markup::Document HoverInfo::present() const {
   // Print Types on their own lines to reduce chances of getting line-wrapped by
   // editor, as they might be long.
   if (ReturnType) {
     // For functions we display signature in a list form, e.g.:
     // → `x`
     // Parameters:
     // - `bool param1`
     // - `int param2 = 5`
-    Output.addParagraph().appendText("→ ").appendCode(*ReturnType);
+    std::string Buffer;
+    llvm::raw_string_ostream OS(Buffer);
+    OS << ReturnType;
+    Output.addParagraph().appendText("→ ").appendCode(OS.str());
     if (Parameters && !Parameters->empty()) {
       Output.addParagraph().appendText("Parameters: ");
       markup::BulletList &L = Output.addBulletList();
       for (const auto &Param : *Parameters) {
         std::string Buffer;
         llvm::raw_string_ostream OS(Buffer);
         OS << Param;
         L.addItem().addParagraph().appendCode(std::move(OS.str()));
       }
     }
   } else if (Type) {
-    Output.addParagraph().appendText("Type: ").appendCode(*Type);
+    std::string Buffer;
+    llvm::raw_string_ostream OS(Buffer);
+    OS << Type;
+    Output.addParagraph().appendText("Type: ").appendCode(OS.str());
   }
 
   if (Value) {
     markup::Paragraph &P = Output.addParagraph();
     P.appendText("Value = ");
     P.appendCode(*Value);
   }
 
if (CallPassType->PassBy != HoverInfo::PassType::Value) {
       OS << "by ";
       if (CallPassType->PassBy == HoverInfo::PassType::ConstRef)
         OS << "const ";
       OS << "reference ";
     }
     if (CalleeArgInfo->Name)
       OS << "as " << CalleeArgInfo->Name;
     if (CallPassType->Converted && CalleeArgInfo->Type)
-      OS << " (converted to " << CalleeArgInfo->Type << ")";
+      OS << " (converted to " << CalleeArgInfo->Type->Type << ")";
     Output.addParagraph().appendText(OS.str());
   }
 
   if (!Documentation.empty())
     parseDocumentation(Documentation, Output);
 
   if (!Definition.empty()) {
     Output.addRuler();
     std::string ScopeComment;
     // Drop trailing "::".
     if (!LocalScope.empty()) {
       // Container name, e.g. class, method, function.
for (std::tie(Line, Rest) = Input.split('\n');
     if (isParagraphBreak(Rest) || isHardLineBreakAfter(Line, Rest)) {
       FlushParagraph();
     }
   }
   FlushParagraph();
 }
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
+                              const HoverInfo::PrintedType &T) {
+  OS << T.Type;
+  if (T.AKA)
+    OS << " (aka " << *T.AKA << ")";
+  return OS;
+}
+
+llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
                               const HoverInfo::Param &P) {
   std::vector<llvm::StringRef> Output;
   if (P.Type)
-    Output.push_back(*P.Type);
+    Output.push_back(P.Type->Type);
   if (P.Name)
     Output.push_back(*P.Name);
   OS << llvm::join(Output, " ");
   if (P.Default)
     OS << " = " << *P.Default;
+  if (P.Type && P.Type->AKA)
+    OS << llvm::formatv(" (aka {0})", *P.Type->AKA);
   return OS;
 }
 
 } // namespace clangd
 } // namespace clang

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

const std::function<void(HoverInfo &)> ExpectedBuilder;
           void [[fo^o]]() {}
           )cpp",
        [](HoverInfo &HI) {
          HI.NamespaceScope = "";
          HI.Name = "foo";
          HI.Kind = index::SymbolKind::Function;
          HI.Documentation = "Best foo ever.";
          HI.Definition = "void foo()";
-         HI.ReturnType = "void";
-         HI.Type = "void ()";
+         HI.ReturnType = {"void", llvm::None};
+         HI.Type = {"void ()", llvm::None};
          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 = index::SymbolKind::Function;
          HI.Documentation = "Best foo ever.";
          HI.Definition = "void foo()";
-         HI.ReturnType = "void";
-         HI.Type = "void ()";
+         HI.ReturnType = {"void", llvm::None};
+         HI.Type = {"void ()", llvm::None};
          HI.Parameters.emplace();
        }},
       // Field
       {R"cpp(
           namespace ns1 { namespace ns2 {
             class Foo {
               char [[b^ar]];
               double y[2];
             };
           }}
           )cpp",
        [](HoverInfo &HI) {
          HI.NamespaceScope = "ns1::ns2::";
          HI.LocalScope = "Foo::";
          HI.Name = "bar";
          HI.Kind = index::SymbolKind::Field;
          HI.Definition = "char bar";
-         HI.Type = "char";
+         HI.Type = {"char", llvm::None};
          HI.Offset = 0;
          HI.Size = 1;
          HI.Padding = 7;
          HI.AccessSpecifier = "private";
        }},
       // Union field
       {R"cpp(
             union Foo {
               char [[b^ar]];
               double y[2];
             };
           )cpp",
        [](HoverInfo &HI) {
          HI.NamespaceScope = "";
          HI.LocalScope = "Foo::";
          HI.Name = "bar";
          HI.Kind = index::SymbolKind::Field;
          HI.Definition = "char bar";
-         HI.Type = "char";
+         HI.Type = {"char", llvm::None};
          HI.Size = 1;
          HI.Padding = 15;
          HI.AccessSpecifier = "public";
        }},
       // Bitfield
       {R"cpp(
             struct Foo {
               int [[^x]] : 1;
               int y : 1;
             };
           )cpp",
        [](HoverInfo &HI) {
          HI.NamespaceScope = "";
          HI.LocalScope = "Foo::";
          HI.Name = "x";
          HI.Kind = index::SymbolKind::Field;
          HI.Definition = "int x : 1";
-         HI.Type = "int";
+         HI.Type = {"int", llvm::None};
          HI.AccessSpecifier = "public";
        }},
       // 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 = index::SymbolKind::Variable;
          HI.Definition = "int bar";
-         HI.Type = "int";
+         HI.Type = {"int", llvm::None};
        }},
       // Anon namespace and local scope.
       {R"cpp(
           namespace ns1 { namespace {
             struct {
               char [[b^ar]];
             } T;
           }}
           )cpp",
        [](HoverInfo &HI) {
          HI.NamespaceScope = "ns1::";
          HI.LocalScope = "(anonymous struct)::";
          HI.Name = "bar";
          HI.Kind = index::SymbolKind::Field;
          HI.Definition = "char bar";
-         HI.Type = "char";
+         HI.Type = {"char", llvm::None};
          HI.Offset = 0;
          HI.Size = 1;
          HI.AccessSpecifier = "public";
        }},
       // Struct definition shows size.
       {R"cpp(
           struct [[^X]]{};
           )cpp",
const std::function<void(HoverInfo &)> ExpectedBuilder;
           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 = index::SymbolKind::Variable;
          HI.Definition = "Foo<int, char, bool> foo = Foo<int, char, bool>(5)";
-         HI.Type = "Foo<int, char, bool>";
+         HI.Type = {"Foo<int, char, bool>", llvm::None};
        }},
       // Implicit template instantiation
       {R"cpp(
           template <typename T> class vector{};
           [[vec^tor]]<int> foo;
           )cpp",
        [](HoverInfo &HI) {
          HI.NamespaceScope = "";
const std::function<void(HoverInfo &)> ExpectedBuilder;
          HI.NamespaceScope = "";
          HI.Name = "Foo";
          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")},
-             {std::string("int"), llvm::None, std::string("0")},
-             {std::string("bool"), std::string("Q"), std::string("false")},
-             {std::string("class..."), std::string("Ts"), llvm::None},
+             {{{std::string("template <typename, bool...> class"), llvm::None}},
+              std::string("C"),
+              llvm::None},
+             {{{std::string("typename"), llvm::None}},
+              llvm::None,
+              std::string("char")},
+             {{{std::string("int"), llvm::None}}, llvm::None, std::string("0")},
+             {{{std::string("bool"), llvm::None}},
+              std::string("Q"),
+              std::string("false")},
+             {{{std::string("class..."), llvm::None}},
+              std::string("Ts"),
+              llvm::None},
          };
        }},
       // Function template
       {R"cpp(
           template <template<typename, bool...> class C,
                     typename = char,
                     int = 0,
                     bool Q = false,
                     class... Ts> void foo();
           template<typename, bool...> class Foo;
 
           void bar() {
             [[fo^o]]<Foo>();
           }
           )cpp",
        [](HoverInfo &HI) {
          HI.NamespaceScope = "";
          HI.Name = "foo";
          HI.Kind = index::SymbolKind::Function;
          HI.Definition = "template <> void foo<Foo, char, 0, false, <>>()";
-         HI.ReturnType = "void";
-         HI.Type = "void ()";
+         HI.ReturnType = {"void", llvm::None};
+         HI.Type = {"void ()", llvm::None};
          HI.Parameters.emplace();
        }},
       // Function decl
       {R"cpp(
           template<typename, bool...> class Foo {};
           Foo<bool, true, false> foo(int, bool T = false);
 
           void bar() {
             [[fo^o]](3);
           }
           )cpp",
        [](HoverInfo &HI) {
          HI.NamespaceScope = "";
          HI.Name = "foo";
          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.ReturnType = {"Foo<bool, true, false>", llvm::None};
+         HI.Type = {"Foo<bool, true, false> (int, bool)", llvm::None};
          HI.Parameters = {
-             {std::string("int"), llvm::None, llvm::None},
-             {std::string("bool"), std::string("T"), std::string("false")},
+             {{{std::string("int"), llvm::None}}, llvm::None, llvm::None},
+             {{{std::string("bool"), llvm::None}},
+              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 = index::SymbolKind::Variable;
          HI.Definition = "auto *c = &b";
-         HI.Type = "(lambda) **";
-         HI.ReturnType = "bool";
+         HI.Type = {"(lambda) **", llvm::None};
+         HI.ReturnType = {"bool", llvm::None};
          HI.Parameters = {
-             {std::string("int"), std::string("T"), llvm::None},
-             {std::string("bool"), std::string("B"), llvm::None},
+             {{{std::string("int"), llvm::None}}, std::string("T"), llvm::None},
+             {{{std::string("bool"), llvm::None}},
+              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 = index::SymbolKind::Parameter;
          HI.Definition = "decltype(lamb) &bar";
-         HI.Type = "decltype(lamb) &";
-         HI.ReturnType = "bool";
+         HI.Type = {"decltype(lamb) &", {"(lambda) &"}};
+         HI.ReturnType = {"bool", llvm::None};
          HI.Parameters = {
-             {std::string("int"), std::string("T"), llvm::None},
-             {std::string("bool"), std::string("B"), llvm::None},
+             {{{std::string("int"), llvm::None}}, std::string("T"), llvm::None},
+             {{{std::string("bool"), llvm::None}},
+              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 = index::SymbolKind::Parameter;
          HI.Definition = "decltype(lamb) bar";
-         HI.Type = "class (lambda)";
-         HI.ReturnType = "bool";
+         HI.Type = {"class (lambda)", llvm::None};
+         HI.ReturnType = {"bool", llvm::None};
          HI.Parameters = {
-             {std::string("int"), std::string("T"), llvm::None},
-             {std::string("bool"), std::string("B"), llvm::None},
+             {{{std::string("int"), llvm::None}}, std::string("T"), llvm::None},
+             {{{std::string("bool"), llvm::None}},
+              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 = index::SymbolKind::Variable;
          HI.Definition = "auto lamb = [&bar](int T, bool B) -> bool {}";
-         HI.Type = "class (lambda)";
-         HI.ReturnType = "bool";
+         HI.Type = {"class (lambda)", llvm::None};
+         HI.ReturnType = {"bool", llvm::None};
          HI.Parameters = {
-             {std::string("int"), std::string("T"), llvm::None},
-             {std::string("bool"), std::string("B"), llvm::None},
+             {{{std::string("int"), llvm::None}}, std::string("T"), llvm::None},
+             {{{std::string("bool"), llvm::None}},
+              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 = index::SymbolKind::Variable;
          HI.Definition = "int test";
-         HI.Type = "int";
+         HI.Type = {"int", llvm::None};
        }},
       // 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 *>";
class Foo {})cpp";
       {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 = index::SymbolKind::Variable;
-         HI.Type = "int";
+         HI.Type = {"int", llvm::None};
          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 = index::SymbolKind::Variable;
-         HI.Type = "int";
+         HI.Type = {"int", llvm::None};
          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 = index::SymbolKind::Variable;
-         HI.Type = "int";
+         HI.Type = {"int", llvm::None};
          HI.NamespaceScope = "";
          HI.Value = "3";
        }},
       {R"cpp(
         enum Color { RED = -123, GREEN = 5, };
         Color x = [[GR^EEN]];
        )cpp",
        [](HoverInfo &HI) {
          HI.Name = "GREEN";
          HI.NamespaceScope = "";
          HI.LocalScope = "Color::";
          HI.Definition = "GREEN = 5";
          HI.Kind = index::SymbolKind::EnumConstant;
-         HI.Type = "enum Color";
+         HI.Type = {"enum Color", llvm::None};
          HI.Value = "5"; // Numeric on the enumerator name, no hex as small.
        }},
       {R"cpp(
         enum Color { RED = -123, GREEN = 5, };
         Color x = RED;
         Color y = [[^x]];
        )cpp",
        [](HoverInfo &HI) {
          HI.Name = "x";
          HI.NamespaceScope = "";
          HI.Definition = "Color x = RED";
          HI.Kind = index::SymbolKind::Variable;
-         HI.Type = "enum Color";
+         HI.Type = {"enum Color", llvm::None};
          HI.Value = "RED (0xffffff85)"; // Symbolic on an expression.
        }},
       {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 = index::SymbolKind::StaticProperty;
-         HI.Type = "const int";
+         HI.Type = {"const int", llvm::None};
          HI.NamespaceScope = "";
          HI.LocalScope = "Add<1, 2>::";
          HI.Value = "3";
          HI.AccessSpecifier = "public";
        }},
       {R"cpp(
-        constexpr int answer() { return 40 + 2; }
+        using my_int = int;
+        constexpr my_int answer() { return 40 + 2; }
         int x = [[ans^wer]]();
         )cpp",
        [](HoverInfo &HI) {
          HI.Name = "answer";
-         HI.Definition = "constexpr int answer()";
+         HI.Definition = "constexpr my_int answer()";
          HI.Kind = index::SymbolKind::Function;
-         HI.Type = "int ()";
-         HI.ReturnType = "int";
+         HI.Type = {"my_int ()", {"int ()"}};
+         HI.ReturnType = {"my_int", {"int"}};
          HI.Parameters.emplace();
          HI.NamespaceScope = "";
          HI.Value = "42 (0x2a)";
        }},
       {R"cpp(
         const char *[[ba^r]] = "1234";
         )cpp",
        [](HoverInfo &HI) {
          HI.Name = "bar";
          HI.Definition = "const char *bar = \"1234\"";
          HI.Kind = index::SymbolKind::Variable;
-         HI.Type = "const char *";
+         HI.Type = {"const char *", llvm::None};
          HI.NamespaceScope = "";
          HI.Value = "&\"1234\"[0]";
        }},
       {R"cpp(// Should not crash
         template <typename T>
         struct Tmpl {
           Tmpl(int name);
         };
 
         template <typename A>
         void boom(int name) {
           new Tmpl<A>([[na^me]]);
         })cpp",
        [](HoverInfo &HI) {
          HI.Name = "name";
          HI.Definition = "int name";
          HI.Kind = index::SymbolKind::Parameter;
-         HI.Type = "int";
+         HI.Type = {"int", llvm::None};
          HI.NamespaceScope = "";
          HI.LocalScope = "boom::";
        }},
       {
           R"cpp(// Should not print inline or anon namespaces.
           namespace ns {
             inline namespace in_ns {
               namespace a {
class Foo {})cpp";
           template <typename [[^T]] = int> void foo();
           )cpp",
        [](HoverInfo &HI) {
          HI.Name = "T";
          HI.Kind = index::SymbolKind::TemplateTypeParm;
          HI.NamespaceScope = "";
          HI.Definition = "typename T = int";
          HI.LocalScope = "foo::";
-         HI.Type = "typename";
+         HI.Type = {"typename", llvm::None};
          HI.AccessSpecifier = "public";
        }},
       {// TemplateTemplate Type Parameter
        R"cpp(
           template <template<typename> class [[^T]]> void foo();
           )cpp",
        [](HoverInfo &HI) {
          HI.Name = "T";
          HI.Kind = index::SymbolKind::TemplateTemplateParm;
          HI.NamespaceScope = "";
          HI.Definition = "template <typename> class T";
          HI.LocalScope = "foo::";
-         HI.Type = "template <typename> class";
+         HI.Type = {"template <typename> class", llvm::None};
          HI.AccessSpecifier = "public";
        }},
       {// NonType Template Parameter
        R"cpp(
           template <int [[^T]] = 5> void foo();
           )cpp",
        [](HoverInfo &HI) {
          HI.Name = "T";
          HI.Kind = index::SymbolKind::NonTypeTemplateParm;
          HI.NamespaceScope = "";
          HI.Definition = "int T = 5";
          HI.LocalScope = "foo::";
-         HI.Type = "int";
+         HI.Type = {"int", llvm::None};
          HI.AccessSpecifier = "public";
        }},
 
       {// Getter
        R"cpp(
           struct X { int Y; float [[^y]]() { return Y; } };
           )cpp",
        [](HoverInfo &HI) {
          HI.Name = "y";
          HI.Kind = index::SymbolKind::InstanceMethod;
          HI.NamespaceScope = "";
          HI.Definition = "float y()";
          HI.LocalScope = "X::";
          HI.Documentation = "Trivial accessor for `Y`.";
-         HI.Type = "float ()";
-         HI.ReturnType = "float";
+         HI.Type = {"float ()", llvm::None};
+         HI.ReturnType = {"float", llvm::None};
          HI.Parameters.emplace();
          HI.AccessSpecifier = "public";
        }},
       {// Setter
        R"cpp(
           struct X { int Y; void [[^setY]](float v) { Y = v; } };
           )cpp",
        [](HoverInfo &HI) {
          HI.Name = "setY";
          HI.Kind = index::SymbolKind::InstanceMethod;
          HI.NamespaceScope = "";
          HI.Definition = "void setY(float v)";
          HI.LocalScope = "X::";
          HI.Documentation = "Trivial setter for `Y`.";
-         HI.Type = "void (float)";
-         HI.ReturnType = "void";
+         HI.Type = {"void (float)", llvm::None};
+         HI.ReturnType = {"void", llvm::None};
          HI.Parameters.emplace();
          HI.Parameters->emplace_back();
-         HI.Parameters->back().Type = "float";
+         HI.Parameters->back().Type = {"float", llvm::None};
          HI.Parameters->back().Name = "v";
          HI.AccessSpecifier = "public";
        }},
       {// Setter (builder)
        R"cpp(
           struct X { int Y; X& [[^setY]](float v) { Y = v; return *this; } };
           )cpp",
        [](HoverInfo &HI) {
          HI.Name = "setY";
          HI.Kind = index::SymbolKind::InstanceMethod;
          HI.NamespaceScope = "";
          HI.Definition = "X &setY(float v)";
          HI.LocalScope = "X::";
          HI.Documentation = "Trivial setter for `Y`.";
-         HI.Type = "X &(float)";
-         HI.ReturnType = "X &";
+         HI.Type = {"X &(float)", llvm::None};
+         HI.ReturnType = {"X &", llvm::None};
          HI.Parameters.emplace();
          HI.Parameters->emplace_back();
-         HI.Parameters->back().Type = "float";
+         HI.Parameters->back().Type = {"float", llvm::None};
          HI.Parameters->back().Name = "v";
          HI.AccessSpecifier = "public";
        }},
       {// Setter (move)
        R"cpp(
           namespace std { template<typename T> T&& move(T&& t); }
           struct X { int Y; void [[^setY]](float v) { Y = std::move(v); } };
           )cpp",
        [](HoverInfo &HI) {
          HI.Name = "setY";
          HI.Kind = index::SymbolKind::InstanceMethod;
          HI.NamespaceScope = "";
          HI.Definition = "void setY(float v)";
          HI.LocalScope = "X::";
          HI.Documentation = "Trivial setter for `Y`.";
-         HI.Type = "void (float)";
-         HI.ReturnType = "void";
+         HI.Type = {"void (float)", llvm::None};
+         HI.ReturnType = {"void", llvm::None};
          HI.Parameters.emplace();
          HI.Parameters->emplace_back();
-         HI.Parameters->back().Type = "float";
+         HI.Parameters->back().Type = {"float", llvm::None};
          HI.Parameters->back().Name = "v";
          HI.AccessSpecifier = "public";
        }},
       {// Field type initializer.
        R"cpp(
           struct X { int x = 2; };
           X ^[[x]];
           )cpp",
        [](HoverInfo &HI) {
          HI.Name = "x";
          HI.Kind = index::SymbolKind::Variable;
          HI.NamespaceScope = "";
          HI.Definition = "X x";
-         HI.Type = "struct X";
+         HI.Type = {"struct X", llvm::None};
        }},
       {// Don't crash on null types.
        R"cpp(auto [^[[x]]] = 1; /*error-ok*/)cpp",
        [](HoverInfo &HI) {
          HI.Name = "x";
          HI.Kind = index::SymbolKind::Variable;
          HI.NamespaceScope = "";
          HI.Definition = "";
-         HI.Type = "NULL TYPE";
+         HI.Type = {"NULL TYPE", llvm::None};
          // Bindings are in theory public members of an anonymous struct.
          HI.AccessSpecifier = "public";
        }},
       {// Extra info for function call.
        R"cpp(
           void fun(int arg_a, int &arg_b) {};
           void code() {
             int a = 1, b = 2;
             fun(a, [[^b]]);
           }
           )cpp",
        [](HoverInfo &HI) {
          HI.Name = "b";
          HI.Kind = index::SymbolKind::Variable;
          HI.NamespaceScope = "";
          HI.Definition = "int b = 2";
          HI.LocalScope = "code::";
          HI.Value = "2";
-         HI.Type = "int";
+         HI.Type = {"int", llvm::None};
          HI.CalleeArgInfo.emplace();
          HI.CalleeArgInfo->Name = "arg_b";
-         HI.CalleeArgInfo->Type = "int &";
+         HI.CalleeArgInfo->Type = {"int &", llvm::None};
          HI.CallPassType.emplace();
          HI.CallPassType->PassBy = PassMode::Ref;
          HI.CallPassType->Converted = false;
        }},
       {// Extra info for method call.
        R"cpp(
           class C {
            public:
             void fun(int arg_a = 3, int arg_b = 4) {}
           };
           void code() {
             int a = 1, b = 2;
             C c;
             c.fun([[^a]], b);
           }
           )cpp",
        [](HoverInfo &HI) {
          HI.Name = "a";
          HI.Kind = index::SymbolKind::Variable;
          HI.NamespaceScope = "";
          HI.Definition = "int a = 1";
          HI.LocalScope = "code::";
          HI.Value = "1";
-         HI.Type = "int";
+         HI.Type = {"int", llvm::None};
          HI.CalleeArgInfo.emplace();
          HI.CalleeArgInfo->Name = "arg_a";
-         HI.CalleeArgInfo->Type = "int";
+         HI.CalleeArgInfo->Type = {"int", llvm::None};
          HI.CalleeArgInfo->Default = "3";
          HI.CallPassType.emplace();
          HI.CallPassType->PassBy = PassMode::Value;
          HI.CallPassType->Converted = false;
        }},
       {// Dont crash on invalid decl
        R"cpp(
         // error-ok
         struct Foo {
           Bar [[x^x]];
         };)cpp",
        [](HoverInfo &HI) {
          HI.Name = "xx";
          HI.Kind = index::SymbolKind::Field;
          HI.NamespaceScope = "";
          HI.Definition = "int xx";
          HI.LocalScope = "Foo::";
-         HI.Type = "int";
+         HI.Type = {"int", llvm::None};
          HI.AccessSpecifier = "public";
        }},
       {R"cpp(
         // error-ok
         struct Foo {
           Bar xx;
           int [[y^y]];
         };)cpp",
        [](HoverInfo &HI) {
          HI.Name = "yy";
          HI.Kind = index::SymbolKind::Field;
          HI.NamespaceScope = "";
          HI.Definition = "int yy";
          HI.LocalScope = "Foo::";
-         HI.Type = "int";
+         HI.Type = {"int", llvm::None};
          HI.AccessSpecifier = "public";
        }},
       {// No crash on InitListExpr.
        R"cpp(
           struct Foo {
             int a[10];
           };
           constexpr Foo k2 = {
             ^[[{]]1} // FIXME: why the hover range is 1 character?
           };
          )cpp",
        [](HoverInfo &HI) {
          HI.Name = "expression";
          HI.Kind = index::SymbolKind::Unknown;
-         HI.Type = "int[10]";
+         HI.Type = {"int[10]", llvm::None};
          HI.Value = "{1}";
+       }},
+      {// Canonical type
+       R"cpp(
+          template<typename T>
+          struct TestHover {
+            using Type = T;
+          };
+
+          void code() {
+            TestHover<int>::Type ^[[a]];
+          }
+         )cpp",
+       [](HoverInfo &HI) {
+         HI.Name = "a";
+         HI.NamespaceScope = "";
+         HI.LocalScope = "code::";
+         HI.Definition = "TestHover<int>::Type a";
+         HI.Kind = index::SymbolKind::Variable;
+         HI.Type = {"TestHover<int>::Type", {"int"}};
+       }},
+      {// Canonical template type
+       R"cpp(
+          template<typename T>
+          void ^[[foo]](T arg) {}
+         )cpp",
+       [](HoverInfo &HI) {
+         HI.Name = "foo";
+         HI.Kind = index::SymbolKind::Function;
+         HI.NamespaceScope = "";
+         HI.Definition = "template <typename T> void foo(T arg)";
+         HI.Type = {"void (T)", llvm::None};
+         HI.ReturnType = {"void", llvm::None};
+         HI.Parameters = {{{{std::string("T"), llvm::None}},
+                           std::string("arg"),
+                           llvm::None}};
+         HI.TemplateParameters = {{{{std::string("typename"), llvm::None}},
+                                   std::string("T"),
+                                   llvm::None}};
+       }},
+      {// TypeAlias Template
+       R"cpp(
+          template<typename T>
+          using ^[[alias]] = T;
+         )cpp",
+       [](HoverInfo &HI) {
+         HI.Name = "alias";
+         HI.NamespaceScope = "";
+         HI.LocalScope = "";
+         HI.Kind = index::SymbolKind::TypeAlias;
+         HI.Definition = "template <typename T> using alias = T";
+         HI.Type = {"T", llvm::None};
+         HI.TemplateParameters = {
+             {{{"typename", llvm::None}}, std::string("T"), llvm::None}};
+       }},
+      {// TypeAlias Template
+       R"cpp(
+          template<typename T>
+          using A = T;
+
+          template<typename T>
+          using ^[[AA]] = A<T>;
+         )cpp",
+       [](HoverInfo &HI) {
+         HI.Name = "AA";
+         HI.NamespaceScope = "";
+         HI.LocalScope = "";
+         HI.Kind = index::SymbolKind::TypeAlias;
+         HI.Definition = "template <typename T> using AA = A<T>";
+         HI.Type = {"A<T>", {"type-parameter-0-0"}}; // FIXME: should be 'T'
+         HI.TemplateParameters = {
+             {{{"typename", llvm::None}}, std::string("T"), llvm::None}};
        }}};
   for (const auto &Case : Cases) {
     SCOPED_TRACE(Case.Code);
 
     Annotations T(Case.Code);
     TestTU TU = TestTU::withCode(T.code());
     TU.ExtraArgs.push_back("-std=c++17");
     // Types might be different depending on the target triplet, we chose a
const std::function<void(HoverInfo &)> ExpectedBuilder;
               int test1 = bonjour;
             }
           )cpp",
           [](HoverInfo &HI) {
             HI.Name = "bonjour";
             HI.Kind = index::SymbolKind::Variable;
             HI.NamespaceScope = "";
             HI.LocalScope = "main::";
-            HI.Type = "int";
+            HI.Type = {"int", llvm::None};
             HI.Definition = "int bonjour";
           }},
       {
           R"cpp(// Local variable in method
             struct s {
               void method() {
                 int bonjour;
                 ^[[bonjour]] = 2;
               }
             };
           )cpp",
           [](HoverInfo &HI) {
             HI.Name = "bonjour";
             HI.Kind = index::SymbolKind::Variable;
             HI.NamespaceScope = "";
             HI.LocalScope = "s::method::";
-            HI.Type = "int";
+            HI.Type = {"int", llvm::None};
             HI.Definition = "int bonjour";
           }},
       {
           R"cpp(// Struct
             namespace ns1 {
               struct MyClass {};
             } // namespace ns1
             int main() {
const std::function<void(HoverInfo &)> ExpectedBuilder;
             int main() {
               auto *X = &^[[foo]];
             }
           )cpp",
           [](HoverInfo &HI) {
             HI.Name = "foo";
             HI.Kind = index::SymbolKind::Function;
             HI.NamespaceScope = "";
-            HI.Type = "void (int)";
+            HI.Type = {"void (int)", llvm::None};
             HI.Definition = "void foo(int)";
             HI.Documentation = "Function definition via pointer";
-            HI.ReturnType = "void";
+            HI.ReturnType = {"void", llvm::None};
             HI.Parameters = {
-                {std::string("int"), llvm::None, llvm::None},
+                {{{std::string("int"), llvm::None}}, llvm::None, llvm::None},
             };
           }},
       {
           R"cpp(// Function declaration via call
             int foo(int);
             int main() {
               return ^[[foo]](42);
             }
           )cpp",
           [](HoverInfo &HI) {
             HI.Name = "foo";
             HI.Kind = index::SymbolKind::Function;
             HI.NamespaceScope = "";
-            HI.Type = "int (int)";
+            HI.Type = {"int (int)", llvm::None};
             HI.Definition = "int foo(int)";
             HI.Documentation = "Function declaration via call";
-            HI.ReturnType = "int";
+            HI.ReturnType = {"int", llvm::None};
             HI.Parameters = {
-                {std::string("int"), llvm::None, llvm::None},
+                {{{std::string("int"), llvm::None}}, llvm::None, llvm::None},
             };
           }},
       {
           R"cpp(// Field
             struct Foo { int x; };
             int main() {
               Foo bar;
               (void)bar.^[[x]];
             }
           )cpp",
           [](HoverInfo &HI) {
             HI.Name = "x";
             HI.Kind = index::SymbolKind::Field;
             HI.NamespaceScope = "";
             HI.LocalScope = "Foo::";
-            HI.Type = "int";
+            HI.Type = {"int", llvm::None};
             HI.Definition = "int x";
           }},
       {
           R"cpp(// Field with initialization
             struct Foo { int x = 5; };
             int main() {
               Foo bar;
               (void)bar.^[[x]];
             }
           )cpp",
           [](HoverInfo &HI) {
             HI.Name = "x";
             HI.Kind = index::SymbolKind::Field;
             HI.NamespaceScope = "";
             HI.LocalScope = "Foo::";
-            HI.Type = "int";
+            HI.Type = {"int", llvm::None};
             HI.Definition = "int x = 5";
           }},
       {
           R"cpp(// Static field
             struct Foo { static int x; };
             int main() {
               (void)Foo::^[[x]];
             }
           )cpp",
           [](HoverInfo &HI) {
             HI.Name = "x";
             HI.Kind = index::SymbolKind::StaticProperty;
             HI.NamespaceScope = "";
             HI.LocalScope = "Foo::";
-            HI.Type = "int";
+            HI.Type = {"int", llvm::None};
             HI.Definition = "static int x";
           }},
       {
           R"cpp(// Field, member initializer
             struct Foo {
               int x;
               Foo() : ^[[x]](0) {}
             };
           )cpp",
           [](HoverInfo &HI) {
             HI.Name = "x";
             HI.Kind = index::SymbolKind::Field;
             HI.NamespaceScope = "";
             HI.LocalScope = "Foo::";
-            HI.Type = "int";
+            HI.Type = {"int", llvm::None};
             HI.Definition = "int x";
           }},
       {
           R"cpp(// Field, GNU old-style field designator
             struct Foo { int x; };
             int main() {
               Foo bar = { ^[[x]] : 1 };
             }
           )cpp",
           [](HoverInfo &HI) {
             HI.Name = "x";
             HI.Kind = index::SymbolKind::Field;
             HI.NamespaceScope = "";
             HI.LocalScope = "Foo::";
-            HI.Type = "int";
+            HI.Type = {"int", llvm::None};
             HI.Definition = "int x";
             // FIXME: Initializer for x is a DesignatedInitListExpr, hence it is
             // of struct type and omitted.
           }},
       {
           R"cpp(// Field, field designator
             struct Foo { int x; int y; };
             int main() {
               Foo bar = { .^[[x]] = 2, .y = 2 };
             }
           )cpp",
           [](HoverInfo &HI) {
             HI.Name = "x";
             HI.Kind = index::SymbolKind::Field;
             HI.NamespaceScope = "";
             HI.LocalScope = "Foo::";
-            HI.Type = "int";
+            HI.Type = {"int", llvm::None};
             HI.Definition = "int x";
           }},
       {
           R"cpp(// Method call
             struct Foo { int x(); };
             int main() {
               Foo bar;
               bar.^[[x]]();
             }
           )cpp",
           [](HoverInfo &HI) {
             HI.Name = "x";
             HI.Kind = index::SymbolKind::InstanceMethod;
             HI.NamespaceScope = "";
             HI.LocalScope = "Foo::";
-            HI.Type = "int ()";
+            HI.Type = {"int ()", llvm::None};
             HI.Definition = "int x()";
-            HI.ReturnType = "int";
+            HI.ReturnType = {"int", llvm::None};
             HI.Parameters = std::vector<HoverInfo::Param>{};
           }},
       {
           R"cpp(// Static method call
             struct Foo { static int x(); };
             int main() {
               Foo::^[[x]]();
             }
           )cpp",
           [](HoverInfo &HI) {
             HI.Name = "x";
             HI.Kind = index::SymbolKind::StaticMethod;
             HI.NamespaceScope = "";
             HI.LocalScope = "Foo::";
-            HI.Type = "int ()";
+            HI.Type = {"int ()", llvm::None};
             HI.Definition = "static int x()";
-            HI.ReturnType = "int";
+            HI.ReturnType = {"int", llvm::None};
             HI.Parameters = std::vector<HoverInfo::Param>{};
           }},
       {
           R"cpp(// Typedef
             typedef int Foo;
             int main() {
               ^[[Foo]] bar;
             }
           )cpp",
           [](HoverInfo &HI) {
             HI.Name = "Foo";
             HI.Kind = index::SymbolKind::TypeAlias;
             HI.NamespaceScope = "";
             HI.Definition = "typedef int Foo";
+            HI.Type = {"int", llvm::None};
             HI.Documentation = "Typedef";
             // FIXME: Maybe put underlying type into HI.Type for aliases?
           }},
       {
           R"cpp(// Typedef with embedded definition
             typedef struct Bar {} Foo;
             int main() {
               ^[[Foo]] bar;
             }
           )cpp",
           [](HoverInfo &HI) {
             HI.Name = "Foo";
             HI.Kind = index::SymbolKind::TypeAlias;
             HI.NamespaceScope = "";
             HI.Definition = "typedef struct Bar Foo";
+            HI.Type = {"struct Bar", llvm::None};
             HI.Documentation = "Typedef with embedded definition";
           }},
       {
           R"cpp(// Namespace
             namespace ns {
             struct Foo { static void bar(); };
             } // namespace ns
             int main() { ^[[ns]]::Foo::bar(); }
const std::function<void(HoverInfo &)> ExpectedBuilder;
               } // anonymous namespace
             } // namespace ns
             int main() { ns::[[f^oo]]++; }
           )cpp",
           [](HoverInfo &HI) {
             HI.Name = "foo";
             HI.Kind = index::SymbolKind::Variable;
             HI.NamespaceScope = "ns::";
-            HI.Type = "int";
+            HI.Type = {"int", llvm::None};
             HI.Definition = "int foo";
           }},
       {
           R"cpp(// Macro
             #define MACRO 0
             int main() { return ^[[MACRO]]; }
           )cpp",
           [](HoverInfo &HI) {
const std::function<void(HoverInfo &)> ExpectedBuilder;
             void foo();
             void g() { [[f^oo]](); }
             void foo() {}
           )cpp",
           [](HoverInfo &HI) {
             HI.Name = "foo";
             HI.Kind = index::SymbolKind::Function;
             HI.NamespaceScope = "";
-            HI.Type = "void ()";
+            HI.Type = {"void ()", llvm::None};
             HI.Definition = "void foo()";
             HI.Documentation = "Function declaration";
-            HI.ReturnType = "void";
+            HI.ReturnType = {"void", llvm::None};
             HI.Parameters = std::vector<HoverInfo::Param>{};
           }},
       {
           R"cpp(// Enum declaration
             enum Hello {
               ONE, TWO, THREE,
             };
             void foo() {
const std::function<void(HoverInfo &)> ExpectedBuilder;
               Hello hello = [[O^NE]];
             }
           )cpp",
           [](HoverInfo &HI) {
             HI.Name = "ONE";
             HI.Kind = index::SymbolKind::EnumConstant;
             HI.NamespaceScope = "";
             HI.LocalScope = "Hello::";
-            HI.Type = "enum Hello";
+            HI.Type = {"enum Hello", llvm::None};
             HI.Definition = "ONE";
             HI.Value = "0";
           }},
       {
           R"cpp(// Enumerator in anonymous enum
             enum {
               ONE, TWO, THREE,
             };
             void foo() {
               int hello = [[O^NE]];
             }
           )cpp",
           [](HoverInfo &HI) {
             HI.Name = "ONE";
             HI.Kind = index::SymbolKind::EnumConstant;
             HI.NamespaceScope = "";
             // FIXME: This should be `(anon enum)::`
             HI.LocalScope = "";
-            HI.Type = "enum (unnamed)";
+            HI.Type = {"enum (unnamed)", llvm::None};
             HI.Definition = "ONE";
             HI.Value = "0";
           }},
       {
           R"cpp(// Global variable
             static int hey = 10;
             void foo() {
               [[he^y]]++;
             }
           )cpp",
           [](HoverInfo &HI) {
             HI.Name = "hey";
             HI.Kind = index::SymbolKind::Variable;
             HI.NamespaceScope = "";
-            HI.Type = "int";
+            HI.Type = {"int", llvm::None};
             HI.Definition = "static int hey = 10";
             HI.Documentation = "Global variable";
             // FIXME: Value shouldn't be set in this case
             HI.Value = "10 (0xa)";
           }},
       {
           R"cpp(// Global variable in namespace
             namespace ns1 {
               static long long hey = -36637162602497;
             }
             void foo() {
               ns1::[[he^y]]++;
             }
           )cpp",
           [](HoverInfo &HI) {
             HI.Name = "hey";
             HI.Kind = index::SymbolKind::Variable;
             HI.NamespaceScope = "ns1::";
-            HI.Type = "long long";
+            HI.Type = {"long long", llvm::None};
             HI.Definition = "static long long hey = -36637162602497";
             HI.Value = "-36637162602497 (0xffffdeadbeefffff)"; // needs 64 bits
           }},
       {
           R"cpp(// Field in anonymous struct
             static struct {
               int hello;
             } s;
             void foo() {
               s.[[he^llo]]++;
             }
           )cpp",
           [](HoverInfo &HI) {
             HI.Name = "hello";
             HI.Kind = index::SymbolKind::Field;
             HI.NamespaceScope = "";
             HI.LocalScope = "(anonymous struct)::";
-            HI.Type = "int";
+            HI.Type = {"int", llvm::None};
             HI.Definition = "int hello";
           }},
       {
           R"cpp(// Templated function
             template <typename T>
             T foo() {
               return 17;
             }
             void g() { auto x = [[f^oo]]<int>(); }
           )cpp",
           [](HoverInfo &HI) {
             HI.Name = "foo";
             HI.Kind = index::SymbolKind::Function;
             HI.NamespaceScope = "";
-            HI.Type = "int ()";
+            HI.Type = {"int ()", llvm::None};
             HI.Definition = "template <> int foo<int>()";
             HI.Documentation = "Templated function";
-            HI.ReturnType = "int";
+            HI.ReturnType = {"int", llvm::None};
             HI.Parameters = std::vector<HoverInfo::Param>{};
             // FIXME: We should populate template parameters with arguments in
             // case of instantiations.
           }},
       {
           R"cpp(// Anonymous union
             struct outer {
               union {
                 int abc, def;
               } v;
             };
             void g() { struct outer o; o.v.[[d^ef]]++; }
           )cpp",
           [](HoverInfo &HI) {
             HI.Name = "def";
             HI.Kind = index::SymbolKind::Field;
             HI.NamespaceScope = "";
             HI.LocalScope = "outer::(anonymous union)::";
-            HI.Type = "int";
+            HI.Type = {"int", llvm::None};
             HI.Definition = "int def";
           }},
       {
           R"cpp(// documentation from index
             int nextSymbolIsAForwardDeclFromIndexWithNoLocalDocs;
             void indexSymbol();
             void g() { [[ind^exSymbol]](); }
           )cpp",
           [](HoverInfo &HI) {
             HI.Name = "indexSymbol";
             HI.Kind = index::SymbolKind::Function;
             HI.NamespaceScope = "";
-            HI.Type = "void ()";
+            HI.Type = {"void ()", llvm::None};
             HI.Definition = "void indexSymbol()";
-            HI.ReturnType = "void";
+            HI.ReturnType = {"void", llvm::None};
             HI.Parameters = std::vector<HoverInfo::Param>{};
             HI.Documentation = "comment from index";
           }},
       {
           R"cpp(// Simple initialization with auto
             void foo() {
               ^[[auto]] i = 1;
             }
const std::function<void(HoverInfo &)> ExpectedBuilder;
             struct Test {};
             void test() { Test && [[te^st]] = {}; }
           )cpp",
           [](HoverInfo &HI) {
             HI.Name = "test";
             HI.Kind = index::SymbolKind::Variable;
             HI.NamespaceScope = "";
             HI.LocalScope = "test::";
-            HI.Type = "Test &&";
+            HI.Type = {"Test &&", llvm::None};
             HI.Definition = "Test &&test = {}";
           }},
       {
           R"cpp(// auto on alias
           typedef int int_type;
           ^[[auto]] x = int_type();
           )cpp",
           [](HoverInfo &HI) {
             HI.Name = "auto";
             HI.Kind = index::SymbolKind::TypeAlias;
-            HI.Definition = "int_type";
+            HI.Definition = "int_type // aka: int";
           }},
       {
           R"cpp(// auto on alias
           struct cls {};
           typedef cls cls_type;
           ^[[auto]] y = cls_type();
           )cpp",
           [](HoverInfo &HI) {
             HI.Name = "auto";
             HI.Kind = index::SymbolKind::TypeAlias;
-            HI.Definition = "cls_type";
+            HI.Definition = "cls_type // aka: cls";
             HI.Documentation = "auto on alias";
           }},
       {
           R"cpp(// auto on alias
           template <class>
           struct templ {};
           ^[[auto]] z = templ<int>();
           )cpp",

           )cpp",
           [](HoverInfo &HI) {
             HI.Definition = "int method()";
             HI.Kind = index::SymbolKind::InstanceMethod;
             HI.NamespaceScope = "";
             HI.LocalScope = "cls<int>::";
             HI.Name = "method";
             HI.Parameters.emplace();
-            HI.ReturnType = "int";
-            HI.Type = "int ()";
+            HI.ReturnType = {"int", llvm::None};
+            HI.Type = {"int ()", llvm::None};
           }},
       {
           R"cpp(// type of nested templates.
           template <class T> struct cls {};
           cls<cls<cls<int>>> [[fo^o]];
           )cpp",
           [](HoverInfo &HI) {
             HI.Definition = "cls<cls<cls<int>>> foo";
             HI.Kind = index::SymbolKind::Variable;
             HI.NamespaceScope = "";
             HI.Name = "foo";
-            HI.Type = "cls<cls<cls<int>>>";
+            HI.Type = {"cls<cls<cls<int>>>", llvm::None};
           }},
       {
           R"cpp(// type of nested templates.
           template <class T> struct cls {};
           [[cl^s]]<cls<cls<int>>> foo;
           )cpp",
           [](HoverInfo &HI) {
             HI.Definition = "template <> struct cls<cls<cls<int>>> {}";
             HI.Kind = index::SymbolKind::Struct;
             HI.NamespaceScope = "";
             HI.Name = "cls<cls<cls<int>>>";
             HI.Documentation = "type of nested templates.";
           }},
       {
           R"cpp(// type with decltype
           int a;
           decltype(a) [[b^]] = a;)cpp",
           [](HoverInfo &HI) {
             HI.Definition = "decltype(a) b = a";
             HI.Kind = index::SymbolKind::Variable;
             HI.NamespaceScope = "";
             HI.Name = "b";
-            HI.Type = "int";
+            HI.Type = {"int", llvm::None};
           }},
       {
           R"cpp(// type with decltype
           int a;
           decltype(a) c;
           decltype(c) [[b^]] = a;)cpp",
           [](HoverInfo &HI) {
             HI.Definition = "decltype(c) b = a";
             HI.Kind = index::SymbolKind::Variable;
             HI.NamespaceScope = "";
             HI.Name = "b";
-            HI.Type = "int";
+            HI.Type = {"int", llvm::None};
           }},
       {
           R"cpp(// type with decltype
           int a;
           const decltype(a) [[b^]] = a;)cpp",
           [](HoverInfo &HI) {
             HI.Definition = "const decltype(a) b = a";
             HI.Kind = index::SymbolKind::Variable;
             HI.NamespaceScope = "";
             HI.Name = "b";
-            HI.Type = "int";
+            HI.Type = {"int", llvm::None};
           }},
       {
           R"cpp(// type with decltype
           int a;
           auto [[f^oo]](decltype(a) x) -> decltype(a) { return 0; })cpp",
           [](HoverInfo &HI) {
             HI.Definition = "auto foo(decltype(a) x) -> decltype(a)";
             HI.Kind = index::SymbolKind::Function;
             HI.NamespaceScope = "";
             HI.Name = "foo";
             // FIXME: Handle composite types with decltype with a printing
             // policy.
-            HI.Type = "auto (decltype(a)) -> decltype(a)";
-            HI.ReturnType = "int";
-            HI.Parameters = {
-                {std::string("int"), std::string("x"), llvm::None}};
+            HI.Type = {"auto (decltype(a)) -> decltype(a)",
+                       {"auto (int) -> int"}};
+            HI.ReturnType = {"int", llvm::None};
+            HI.Parameters = {{{{std::string("int"), llvm::None}},
+                              std::string("x"),
+                              llvm::None}};
           }},
       {
           R"cpp(// sizeof expr
           void foo() {
             (void)[[size^of]](char);
           })cpp",
           [](HoverInfo &HI) {
             HI.Name = "expression";
-            HI.Type = "unsigned long";
+            HI.Type = {"unsigned long", llvm::None};
             HI.Value = "1";
           }},
       {
           R"cpp(// alignof expr
           void foo() {
             (void)[[align^of]](char);
           })cpp",
           [](HoverInfo &HI) {
             HI.Name = "expression";
-            HI.Type = "unsigned long";
+            HI.Type = {"unsigned long", llvm::None};
             HI.Value = "1";
           }},
       {
           R"cpp(
           template <typename T = int>
           void foo(const T& = T()) {
             [[f^oo]]<>(3);
           })cpp",
           [](HoverInfo &HI) {
             HI.Name = "foo";
             HI.Kind = index::SymbolKind::Function;
-            HI.Type = "void (const int &)";
-            HI.ReturnType = "void";
-            HI.Parameters = {
-                {std::string("const int &"), llvm::None, std::string("T()")}};
+            HI.Type = {"void (const int &)", llvm::None};
+            HI.ReturnType = {"void", llvm::None};
+            HI.Parameters = {{{{std::string("const int &"), llvm::None}},
+                              llvm::None,
+                              std::string("T()")}};
             HI.Definition = "template <> void foo<int>(const int &)";
             HI.NamespaceScope = "";
           }},
       {
           R"cpp(// should not crash
            @interface ObjC {
              char [[da^ta]];
            }@end
           )cpp",
           [](HoverInfo &HI) {
             HI.Name = "data";
-            HI.Type = "char";
+            HI.Type = {"char", llvm::None};
             HI.Kind = index::SymbolKind::Field;
             HI.LocalScope = "ObjC::";
             HI.NamespaceScope = "";
             HI.Definition = "char data";
           }},
       {
           R"cpp(
           @interface MYObject

           return result;
         }
         @end
         )objc",
        [](HoverInfo &HI) {
          HI.Name = "result";
          HI.Definition = "int result = 2";
          HI.Kind = index::SymbolKind::Variable;
-         HI.Type = "int";
+         HI.Type = {"int", llvm::None};
          HI.LocalScope = "+[Foo(Private) somePrivateMethod]::";
          HI.NamespaceScope = "";
          HI.Value = "2";
        }},
       {R"objc(
         @interface Foo
         @end
 
         @implementation Foo
         - (int)variadicArgMethod:(id)first, ... {
           int [[res^ult]] = 0;
           return result;
         }
         @end
         )objc",
        [](HoverInfo &HI) {
          HI.Name = "result";
          HI.Definition = "int result = 0";
          HI.Kind = index::SymbolKind::Variable;
-         HI.Type = "int";
+         HI.Type = {"int", llvm::None};
          HI.LocalScope = "-[Foo variadicArgMethod:, ...]::";
          HI.NamespaceScope = "";
          HI.Value = "0";
        }},
       {R"cpp(
          void foo(int * __attribute__(([[non^null]], noescape)) );
          )cpp",
        [](HoverInfo &HI) {
llvm::StringRef ExpectedRender;
           },
           R"(namespace-alias foo)",
       },
       {
           [](HoverInfo &HI) {
             HI.Kind = index::SymbolKind::Class;
             HI.Size = 10;
             HI.TemplateParameters = {
-                {std::string("typename"), std::string("T"), llvm::None},
-                {std::string("typename"), std::string("C"),
+                {{{std::string("typename"), llvm::None}},
+                 std::string("T"),
+                 llvm::None},
+                {{{std::string("typename"), llvm::None}},
+                 std::string("C"),
                  std::string("bool")},
             };
             HI.Documentation = "documentation";
             HI.Definition =
                 "template <typename T, typename C = bool> class Foo {}";
             HI.Name = "foo";
             HI.NamespaceScope.emplace();
           },
           R"(class foo
 
 Size: 10 bytes
 documentation
 
 template <typename T, typename C = bool> class Foo {})",
       },
       {
           [](HoverInfo &HI) {
             HI.Kind = index::SymbolKind::Function;
             HI.Name = "foo";
-            HI.Type = "type";
-            HI.ReturnType = "ret_type";
+            HI.Type = {"type", {"c_type"}};
+            HI.ReturnType = {"ret_type", {"can_ret_type"}};
             HI.Parameters.emplace();
             HoverInfo::Param P;
             HI.Parameters->push_back(P);
-            P.Type = "type";
+            P.Type = {"type", {"can_type"}};
             HI.Parameters->push_back(P);
             P.Name = "foo";
             HI.Parameters->push_back(P);
             P.Default = "default";
             HI.Parameters->push_back(P);
             HI.NamespaceScope = "ns::";
             HI.Definition = "ret_type foo(params) {}";
           },
           "function foo\n"
           "\n"
-          "→ ret_type\n"
+          "→ ret_type (aka can_ret_type)\n"
           "Parameters:\n"
           "- \n"
-          "- type\n"
-          "- type foo\n"
-          "- type foo = default\n"
+          "- type (aka can_type)\n"
+          "- type foo (aka can_type)\n"
+          "- type foo = default (aka can_type)\n"
           "\n"
           "// In namespace ns\n"
           "ret_type foo(params) {}",
       },
       {
           [](HoverInfo &HI) {
             HI.Kind = index::SymbolKind::Field;
             HI.LocalScope = "test::Bar::";
             HI.Value = "value";
             HI.Name = "foo";
-            HI.Type = "type";
+            HI.Type = {"type", {"can_type"}};
             HI.Definition = "def";
             HI.Size = 4;
             HI.Offset = 12;
             HI.Padding = 4;
           },
           R"(field foo
 
-Type: type
+Type: type (aka can_type)
 Value = value
 Offset: 12 bytes
 Size: 4 bytes (+4 padding)
 
 // In test::Bar
 def)",
       },
       {
           [](HoverInfo &HI) {
             HI.Kind = index::SymbolKind::Field;
             HI.AccessSpecifier = "public";
             HI.Name = "foo";
             HI.LocalScope = "test::Bar::";
             HI.Definition = "def";
           },
           R"(field foo
 
 // In test::Bar
 public: def)",
       },
       {
           [](HoverInfo &HI) {
-            HI.Definition = "int method()";
+            HI.Definition = "size_t method()";
             HI.AccessSpecifier = "protected";
             HI.Kind = index::SymbolKind::InstanceMethod;
             HI.NamespaceScope = "";
             HI.LocalScope = "cls<int>::";
             HI.Name = "method";
             HI.Parameters.emplace();
-            HI.ReturnType = "int";
-            HI.Type = "int ()";
+            HI.ReturnType = {"size_t", {"unsigned long"}};
+            HI.Type = {"size_t ()", {"unsigned long ()"}};
           },
           R"(instance-method method
 
-→ int
+→ size_t (aka unsigned long)
 
 // In cls<int>
-protected: int method())",
+protected: size_t method())",
       },
       {
           [](HoverInfo &HI) {
             HI.Kind = index::SymbolKind::Union;
             HI.AccessSpecifier = "private";
             HI.Name = "foo";
             HI.NamespaceScope = "ns1::";
             HI.Definition = "union foo {}";
           },
           R"(union foo
 
 // In namespace ns1
 private: union foo {})",
       },
       {
           [](HoverInfo &HI) {
             HI.Kind = index::SymbolKind::Variable;
             HI.Name = "foo";
             HI.Definition = "int foo = 3";
             HI.LocalScope = "test::Bar::";
             HI.Value = "3";
-            HI.Type = "int";
+            HI.Type = {"int", llvm::None};
             HI.CalleeArgInfo.emplace();
             HI.CalleeArgInfo->Name = "arg_a";
-            HI.CalleeArgInfo->Type = "int";
+            HI.CalleeArgInfo->Type = {"int", llvm::None};
             HI.CalleeArgInfo->Default = "7";
             HI.CallPassType.emplace();
             HI.CallPassType->PassBy = PassMode::Value;
             HI.CallPassType->Converted = false;
           },
           R"(variable foo
 
 Type: int
 Value = 3
 Passed as arg_a
 
 // In test::Bar
 int foo = 3)",
       },
       {
           [](HoverInfo &HI) {
             HI.Kind = index::SymbolKind::Variable;
             HI.Name = "foo";
             HI.Definition = "int foo = 3";
             HI.LocalScope = "test::Bar::";
             HI.Value = "3";
-            HI.Type = "int";
+            HI.Type = {"int", llvm::None};
             HI.CalleeArgInfo.emplace();
             HI.CalleeArgInfo->Name = "arg_a";
-            HI.CalleeArgInfo->Type = "int";
+            HI.CalleeArgInfo->Type = {"int", llvm::None};
             HI.CalleeArgInfo->Default = "7";
             HI.CallPassType.emplace();
             HI.CallPassType->PassBy = PassMode::Ref;
             HI.CallPassType->Converted = false;
           },
           R"(variable foo
 
 Type: int
 Value = 3
 Passed by reference as arg_a
 
 // In test::Bar
 int foo = 3)",
       },
       {
           [](HoverInfo &HI) {
             HI.Kind = index::SymbolKind::Variable;
             HI.Name = "foo";
             HI.Definition = "int foo = 3";
             HI.LocalScope = "test::Bar::";
             HI.Value = "3";
-            HI.Type = "int";
+            HI.Type = {"int", llvm::None};
             HI.CalleeArgInfo.emplace();
             HI.CalleeArgInfo->Name = "arg_a";
-            HI.CalleeArgInfo->Type = "int";
+            HI.CalleeArgInfo->Type = {"alias_int", {"int"}};
             HI.CalleeArgInfo->Default = "7";
             HI.CallPassType.emplace();
             HI.CallPassType->PassBy = PassMode::Value;
             HI.CallPassType->Converted = true;
           },
           R"(variable foo
 
 Type: int
 Value = 3
-Passed as arg_a (converted to int)
+Passed as arg_a (converted to alias_int)
 
 // In test::Bar
 int foo = 3)",
       },
       {
           [](HoverInfo &HI) {
             HI.Kind = index::SymbolKind::Variable;
             HI.Name = "foo";
             HI.Definition = "int foo = 3";
             HI.LocalScope = "test::Bar::";
             HI.Value = "3";
-            HI.Type = "int";
+            HI.Type = {"int", llvm::None};
             HI.CalleeArgInfo.emplace();
             HI.CalleeArgInfo->Name = "arg_a";
-            HI.CalleeArgInfo->Type = "int";
+            HI.CalleeArgInfo->Type = {"int", llvm::None};
             HI.CalleeArgInfo->Default = "7";
             HI.CallPassType.emplace();
             HI.CallPassType->PassBy = PassMode::ConstRef;
             HI.CallPassType->Converted = true;
           },
           R"(variable foo
 
 Type: int

clang/include/clang/AST/ASTDiagnostic.h

 //===--- ASTDiagnostic.h - Diagnostics for the AST library ------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_AST_ASTDIAGNOSTIC_H
 #define LLVM_CLANG_AST_ASTDIAGNOSTIC_H
 
+#include "clang/AST/Type.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/DiagnosticAST.h"
 
 namespace clang {
   /// DiagnosticsEngine argument formatting function for diagnostics that
   /// involve AST nodes.
   ///
   /// This function formats diagnostic arguments for various AST nodes,
   /// including types, declaration names, nested name specifiers, and
   /// declaration contexts, into strings that can be printed as part of
   /// diagnostics. It is meant to be used as the argument to
   /// \c DiagnosticsEngine::SetArgToStringFn(), where the cookie is an \c
   /// ASTContext pointer.
   void FormatASTNodeDiagnosticArgument(
       DiagnosticsEngine::ArgumentKind Kind,
       intptr_t Val,
       StringRef Modifier,
       StringRef Argument,
       ArrayRef<DiagnosticsEngine::ArgumentValue> PrevArgs,
       SmallVectorImpl<char> &Output,
       void *Cookie,
       ArrayRef<intptr_t> QualTypeVals);
+
+  /// Returns a desugared version of the QualType, and marks ShouldAKA as true
+  /// whenever we remove significant sugar from the type.
+  QualType Desugar(ASTContext &Context, QualType QT, bool &ShouldAKA);
 }  // end namespace clang
 
 #endif

clang/lib/AST/ASTDiagnostic.cpp

 #include "clang/AST/Type.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace clang;
 
 // Returns a desugared version of the QualType, and marks ShouldAKA as true
 // whenever we remove significant sugar from the type.
-static QualType Desugar(ASTContext &Context, QualType QT, bool &ShouldAKA) {
+QualType clang::Desugar(ASTContext &Context, QualType QT, bool &ShouldAKA) {
   QualifierCollector QC;
 
   while (true) {
     const Type *Ty = QC.strip(QT);
 
     // Don't aka just because we saw an elaborated type...
     if (const ElaboratedType *ET = dyn_cast<ElaboratedType>(Ty)) {
       QT = ET->desugar();