[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

706

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

1090

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

1136

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

clang-tools-extra/clangd/Hover.h

48

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

706

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

174

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

[lh123]

clang-tools-extra/clangd/Hover.cpp

174

Should we set FullyQualifiedName printing policy for DesugaredTy.

[lh123]

clang-tools-extra/clangd/Hover.cpp

174

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

143–144

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

149–150

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

168

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

174

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.

174

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)

195

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...

690

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

690

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

1088–1089

appendCode(llvm::to_string(ReturnType))

(from ScopedPrinter.h)

1256

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

49

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

1256

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

1251

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

1256

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

1256

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

1256

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 {
+    PrintedType() = default;
+    PrintedType(const char *Type) : Type(Type) {}
+    PrintedType(const char *Type, const char *AKAType)
+        : Type(Type), AKA(AKAType) {}
+
+    /// Pretty-printed type
+    std::string Type;
+    /// Desugared type
+    llvm::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"

 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Format.h"
+#include "llvm/Support/ScopedPrinter.h"
 #include "llvm/Support/raw_ostream.h"
 #include <string>
 
 namespace clang {
 namespace clangd {
 namespace {
 
 PrintingPolicy getPrintingPolicy(PrintingPolicy Base) {

 
 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 &ASTCtx,
+                                 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);
+  HoverInfo::PrintedType Result;
+  llvm::raw_string_ostream OS(Result.Type);
   // 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);
+  OS.flush();
+  if (!QT.isNull()) {
+    bool ShouldAKA = false;
+    QualType DesugaredTy = clang::desugarForDiagnostic(ASTCtx, QT, ShouldAKA);
+    if (ShouldAKA)
+      Result.AKA = DesugaredTy.getAsString(PP);
+  }
   return Result;
 }
 
-std::string printType(const TemplateTypeParmDecl *TTP) {
-  std::string Res = TTP->wasDeclaredWithTypename() ? "typename" : "class";
+HoverInfo::PrintedType printType(const TemplateTypeParmDecl *TTP) {
+  HoverInfo::PrintedType Result;
+  Result.Type = TTP->wasDeclaredWithTypename() ? "typename" : "class";
   if (TTP->isParameterPack())
-    Res += "...";
-  return Res;
+    Result.Type += "...";
+  return Result;
 }
 
-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);
+  HoverInfo::PrintedType Result;
+  llvm::raw_string_ostream OS(Result.Type);
   OS << "template <";
   llvm::StringRef Sep = "";
   for (const Decl *Param : *TTP->getTemplateParameters()) {
     OS << Sep;
     Sep = ", ";
     if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(Param))
-      OS << printType(TTP);
+      OS << printType(TTP).Type;
     else if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Param))
-      OS << printType(NTTP, PP);
+      OS << printType(NTTP, PP).Type;
     else if (const auto *TTPD = dyn_cast<TemplateTemplateParmDecl>(Param))
-      OS << printType(TTPD, PP);
+      OS << printType(TTPD, PP).Type;
   }
   // FIXME: TemplateTemplateParameter doesn't store the info on whether this
   // param was a "typename" or "class".
   OS << "> class";
-  return OS.str();
+  OS.flush();
+  return Result;
 }
 
 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";
   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();
if (!Invalid) {
         HI.Definition =
             ("#define " + Buffer.substr(StartOffset, EndOffset - StartOffset))
                 .str();
     }
   }
   return HI;
 }
 
+std::string typeAsDefinition(const HoverInfo::PrintedType &PType) {
+  std::string Result;
+  llvm::raw_string_ostream OS(Result);
+  OS << PType.Type;
+  if (PType.AKA)
+    OS << " // aka: " << *PType.AKA;
+  OS.flush();
+  return Result;
+}
+
 llvm::Optional<HoverInfo> getThisExprHoverContents(const CXXThisExpr *CTE,
                                                    ASTContext &ASTCtx,
                                                    const PrintingPolicy &PP) {
   QualType OriginThisType = CTE->getType()->getPointeeType();
   QualType ClassType = declaredType(OriginThisType->getAsTagDecl());
   // For partial specialization class, origin `this` pointee type will be
   // 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);
+  HI.Definition = typeAsDefinition(printType(PrettyThisType, ASTCtx, PP));
   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);
+    HI.Definition = typeAsDefinition(printType(QT, ASTCtx, PP));
 
     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);
+    Output.addParagraph().appendText("→ ").appendCode(
+        llvm::to_string(*ReturnType));
     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()));
-      }
+      for (const auto &Param : *Parameters)
+        L.addItem().addParagraph().appendCode(llvm::to_string(Param));
     }
   } else if (Type) {
-    Output.addParagraph().appendText("Type: ").appendCode(*Type);
+    Output.addParagraph().appendText("Type: ").appendCode(
+        llvm::to_string(*Type));
   }
 
   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);
+    OS << llvm::to_string(*P.Type);
   if (P.Name)
-    Output.push_back(*P.Name);
-  OS << llvm::join(Output, " ");
+    OS << " " << *P.Name;
   if (P.Default)
     OS << " = " << *P.Default;
   return OS;
 }
 
 } // namespace clangd
 } // namespace clang

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

const std::function<void(HoverInfo &)> ExpectedBuilder;
           )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.Parameters.emplace();
        }},
       // Inside namespace
       {R"cpp(
           namespace ns1 { namespace ns2 {
             /// Best foo ever.
             void [[fo^o]]() {}
           }}
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},
+             {{"template <typename, bool...> class"},
+              std::string("C"),
+              llvm::None},
+             {{"typename"}, llvm::None, std::string("char")},
+             {{"int"}, llvm::None, std::string("0")},
+             {{"bool"}, std::string("Q"), std::string("false")},
+             {{"class..."}, std::string("Ts"), llvm::None},
          };
        }},
       // Function template
       {R"cpp(
           template <template<typename, bool...> class C,
                     typename = char,
                     int = 0,
                     bool Q = false,
class Foo {})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.Parameters = {
-             {std::string("int"), llvm::None, llvm::None},
-             {std::string("bool"), std::string("T"), std::string("false")},
+             {{"int"}, llvm::None, llvm::None},
+             {{"bool"}, std::string("T"), std::string("false")},
          };
        }},
       // Pointers to lambdas
       {R"cpp(
         void foo() {
           auto lamb = [](int T, bool B) -> bool { return T && B; };
           auto *b = &lamb;
           auto *[[^c]] = &b;
         }
         )cpp",
        [](HoverInfo &HI) {
          HI.NamespaceScope = "";
          HI.LocalScope = "foo::";
          HI.Name = "c";
          HI.Kind = index::SymbolKind::Variable;
          HI.Definition = "auto *c = &b";
          HI.Type = "(lambda) **";
          HI.ReturnType = "bool";
          HI.Parameters = {
-             {std::string("int"), std::string("T"), llvm::None},
-             {std::string("bool"), std::string("B"), llvm::None},
+             {{"int"}, std::string("T"), llvm::None},
+             {{"bool"}, std::string("B"), llvm::None},
          };
          return HI;
        }},
       // Lambda parameter with decltype reference
       {R"cpp(
         auto lamb = [](int T, bool B) -> bool { return T && B; };
         void foo(decltype(lamb)& bar) {
           [[ba^r]](0, false);
         }
         )cpp",
        [](HoverInfo &HI) {
          HI.NamespaceScope = "";
          HI.LocalScope = "foo::";
          HI.Name = "bar";
          HI.Kind = index::SymbolKind::Parameter;
          HI.Definition = "decltype(lamb) &bar";
-         HI.Type = "decltype(lamb) &";
+         HI.Type = {"decltype(lamb) &", "(lambda) &"};
          HI.ReturnType = "bool";
          HI.Parameters = {
-             {std::string("int"), std::string("T"), llvm::None},
-             {std::string("bool"), std::string("B"), llvm::None},
+             {{"int"}, std::string("T"), llvm::None},
+             {{"bool"}, std::string("B"), llvm::None},
          };
          return HI;
        }},
       // Lambda parameter with decltype
       {R"cpp(
         auto lamb = [](int T, bool B) -> bool { return T && B; };
         void foo(decltype(lamb) bar) {
           [[ba^r]](0, false);
         }
         )cpp",
        [](HoverInfo &HI) {
          HI.NamespaceScope = "";
          HI.LocalScope = "foo::";
          HI.Name = "bar";
          HI.Kind = index::SymbolKind::Parameter;
          HI.Definition = "decltype(lamb) bar";
          HI.Type = "class (lambda)";
          HI.ReturnType = "bool";
          HI.Parameters = {
-             {std::string("int"), std::string("T"), llvm::None},
-             {std::string("bool"), std::string("B"), llvm::None},
+             {{"int"}, std::string("T"), llvm::None},
+             {{"bool"}, std::string("B"), llvm::None},
          };
          HI.Value = "false";
          return HI;
        }},
       // Lambda variable
       {R"cpp(
         void foo() {
           int bar = 5;
           auto lamb = [&bar](int T, bool B) -> bool { return T && B && bar; };
           bool res = [[lam^b]](bar, false);
         }
         )cpp",
        [](HoverInfo &HI) {
          HI.NamespaceScope = "";
          HI.LocalScope = "foo::";
          HI.Name = "lamb";
          HI.Kind = index::SymbolKind::Variable;
          HI.Definition = "auto lamb = [&bar](int T, bool B) -> bool {}";
          HI.Type = "class (lambda)";
          HI.ReturnType = "bool";
          HI.Parameters = {
-             {std::string("int"), std::string("T"), llvm::None},
-             {std::string("bool"), std::string("B"), llvm::None},
+             {{"int"}, std::string("T"), llvm::None},
+             {{"bool"}, std::string("B"), llvm::None},
          };
          return HI;
        }},
       // Local variable in lambda
       {R"cpp(
         void foo() {
           auto lamb = []{int [[te^st]];};
         }
class Foo {})cpp";
          HI.Kind = index::SymbolKind::StaticProperty;
          HI.Type = "const int";
          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) {
class Foo {})cpp";
             ^[[{]]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.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)";
+         HI.ReturnType = "void";
+         HI.Parameters = {{{"T"}, std::string("arg"), llvm::None}};
+         HI.TemplateParameters = {{{"typename"}, 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";
+         HI.TemplateParameters = {{{"typename"}, 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"}, 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;
             HI.Name = "foo";
             HI.Kind = index::SymbolKind::Function;
             HI.NamespaceScope = "";
             HI.Type = "void (int)";
             HI.Definition = "void foo(int)";
             HI.Documentation = "Function definition via pointer";
             HI.ReturnType = "void";
             HI.Parameters = {
-                {std::string("int"), llvm::None, llvm::None},
+                {{"int"}, 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.Definition = "int foo(int)";
             HI.Documentation = "Function declaration via call";
             HI.ReturnType = "int";
             HI.Parameters = {
-                {std::string("int"), llvm::None, llvm::None},
+                {{"int"}, llvm::None, llvm::None},
             };
           }},
       {
           R"cpp(// Field
             struct Foo { int x; };
             int main() {
               Foo bar;
               (void)bar.^[[x]];
const std::function<void(HoverInfo &)> ExpectedBuilder;
               ^[[Foo]] bar;
             }
           )cpp",
           [](HoverInfo &HI) {
             HI.Name = "Foo";
             HI.Kind = index::SymbolKind::TypeAlias;
             HI.NamespaceScope = "";
             HI.Definition = "typedef int Foo";
+            HI.Type = "int";
             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";
             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;
       {
           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",

           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.Type = {"auto (decltype(a)) -> decltype(a)",
+                       "auto (int) -> int"};
             HI.ReturnType = "int";
-            HI.Parameters = {
-                {std::string("int"), std::string("x"), llvm::None}};
+            HI.Parameters = {{{"int"}, std::string("x"), llvm::None}};
           }},
       {
           R"cpp(// sizeof expr
           void foo() {
             (void)[[size^of]](char);
           })cpp",
           [](HoverInfo &HI) {
             HI.Name = "expression";

           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.Parameters = {{{"const int &"}, 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
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("bool")},
+                {{"typename"}, std::string("T"), llvm::None},
+                {{"typename"}, 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 (aka can_type) foo\n"
+          "- type (aka can_type) foo = default\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 {}";
int foo = 3)",
             HI.Kind = index::SymbolKind::Variable;
             HI.Name = "foo";
             HI.Definition = "int foo = 3";
             HI.LocalScope = "test::Bar::";
             HI.Value = "3";
             HI.Type = "int";
             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";

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);
-}  // end namespace clang
+
+  /// Returns a desugared version of the QualType, and marks ShouldAKA as true
+  /// whenever we remove significant sugar from the type.
+  QualType desugarForDiagnostic(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::desugarForDiagnostic(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();
if (const AutoType *AT = dyn_cast<AutoType>(Ty)) {
       continue;
     }
 
     // Desugar FunctionType if return type or any parameter type should be
     // desugared. Preserve nullability attribute on desugared types.
     if (const FunctionType *FT = dyn_cast<FunctionType>(Ty)) {
       bool DesugarReturn = false;
       QualType SugarRT = FT->getReturnType();
-      QualType RT = Desugar(Context, SugarRT, DesugarReturn);
+      QualType RT = desugarForDiagnostic(Context, SugarRT, DesugarReturn);
       if (auto nullability = AttributedType::stripOuterNullability(SugarRT)) {
         RT = Context.getAttributedType(
             AttributedType::getNullabilityAttrKind(*nullability), RT, RT);
       }
 
       bool DesugarArgument = false;
       SmallVector<QualType, 4> Args;
       const FunctionProtoType *FPT = dyn_cast<FunctionProtoType>(FT);
       if (FPT) {
         for (QualType SugarPT : FPT->param_types()) {
-          QualType PT = Desugar(Context, SugarPT, DesugarArgument);
+          QualType PT = desugarForDiagnostic(Context, SugarPT, DesugarArgument);
           if (auto nullability =
                   AttributedType::stripOuterNullability(SugarPT)) {
             PT = Context.getAttributedType(
                 AttributedType::getNullabilityAttrKind(*nullability), PT, PT);
           }
           Args.push_back(PT);
         }
       }
while (true) {
     if (const TemplateSpecializationType *TST =
             dyn_cast<TemplateSpecializationType>(Ty)) {
       if (!TST->isTypeAlias()) {
         bool DesugarArgument = false;
         SmallVector<TemplateArgument, 4> Args;
         for (unsigned I = 0, N = TST->getNumArgs(); I != N; ++I) {
           const TemplateArgument &Arg = TST->getArg(I);
           if (Arg.getKind() == TemplateArgument::Type)
-            Args.push_back(Desugar(Context, Arg.getAsType(), DesugarArgument));
+            Args.push_back(desugarForDiagnostic(Context, Arg.getAsType(),
+                                                DesugarArgument));
           else
             Args.push_back(Arg);
         }
 
         if (DesugarArgument) {
           ShouldAKA = true;
           QT = Context.getTemplateSpecializationType(
               TST->getTemplateName(), Args, QT);
#include "clang/AST/TypeNodes.inc"
     // Record that we actually looked through an opaque type here.
     ShouldAKA = true;
     QT = Underlying;
   }
 
   // If we have a pointer-like type, desugar the pointee as well.
   // FIXME: Handle other pointer-like types.
   if (const PointerType *Ty = QT->getAs<PointerType>()) {
-    QT = Context.getPointerType(Desugar(Context, Ty->getPointeeType(),
-                                        ShouldAKA));
+    QT = Context.getPointerType(
+        desugarForDiagnostic(Context, Ty->getPointeeType(), ShouldAKA));
   } else if (const auto *Ty = QT->getAs<ObjCObjectPointerType>()) {
-    QT = Context.getObjCObjectPointerType(Desugar(Context, Ty->getPointeeType(),
-                                                  ShouldAKA));
+    QT = Context.getObjCObjectPointerType(
+        desugarForDiagnostic(Context, Ty->getPointeeType(), ShouldAKA));
   } else if (const LValueReferenceType *Ty = QT->getAs<LValueReferenceType>()) {
-    QT = Context.getLValueReferenceType(Desugar(Context, Ty->getPointeeType(),
-                                                ShouldAKA));
+    QT = Context.getLValueReferenceType(
+        desugarForDiagnostic(Context, Ty->getPointeeType(), ShouldAKA));
   } else if (const RValueReferenceType *Ty = QT->getAs<RValueReferenceType>()) {
-    QT = Context.getRValueReferenceType(Desugar(Context, Ty->getPointeeType(),
-                                                ShouldAKA));
+    QT = Context.getRValueReferenceType(
+        desugarForDiagnostic(Context, Ty->getPointeeType(), ShouldAKA));
   } else if (const auto *Ty = QT->getAs<ObjCObjectType>()) {
     if (Ty->getBaseType().getTypePtr() != Ty && !ShouldAKA) {
-      QualType BaseType = Desugar(Context, Ty->getBaseType(), ShouldAKA);
-      QT = Context.getObjCObjectType(BaseType, Ty->getTypeArgsAsWritten(),
-                                     llvm::makeArrayRef(Ty->qual_begin(),
-                                                        Ty->getNumProtocols()),
-                                     Ty->isKindOfTypeAsWritten());
+      QualType BaseType =
+          desugarForDiagnostic(Context, Ty->getBaseType(), ShouldAKA);
+      QT = Context.getObjCObjectType(
+          BaseType, Ty->getTypeArgsAsWritten(),
+          llvm::makeArrayRef(Ty->qual_begin(), Ty->getNumProtocols()),
     }
   }
 
   return QC.apply(Context, QT);
 }
 
 /// Convert the given type to a string suitable for printing as part of
 /// a diagnostic.
if (CompareTy.isNull())
       continue;
     if (CompareTy == Ty)
       continue;  // Same types
     QualType CompareCanTy = CompareTy.getCanonicalType();
     if (CompareCanTy == CanTy)
       continue;  // Same canonical types
     std::string CompareS = CompareTy.getAsString(Context.getPrintingPolicy());
     bool ShouldAKA = false;
-    QualType CompareDesugar = Desugar(Context, CompareTy, ShouldAKA);
+    QualType CompareDesugar =
+        desugarForDiagnostic(Context, CompareTy, ShouldAKA);
     std::string CompareDesugarStr =
         CompareDesugar.getAsString(Context.getPrintingPolicy());
     if (CompareS != S && CompareDesugarStr != S)
       continue;  // The type string is different than the comparison string
                  // and the desugared comparison string.
     std::string CompareCanS =
         CompareCanTy.getAsString(Context.getPrintingPolicy());
 
if (PrevArgs[i].first == DiagnosticsEngine::ak_qualtype) {
       }
     }
   }
 
   // Consider producing an a.k.a. clause if removing all the direct
   // sugar gives us something "significantly different".
   if (!Repeated) {
     bool ShouldAKA = false;
-    QualType DesugaredTy = Desugar(Context, Ty, ShouldAKA);
+    QualType DesugaredTy = desugarForDiagnostic(Context, Ty, ShouldAKA);
     if (ShouldAKA || ForceAKA) {
       if (DesugaredTy == Ty) {
         DesugaredTy = Ty.getCanonicalType();
       }
       std::string akaStr = DesugaredTy.getAsString(Context.getPrintingPolicy());
       if (akaStr != S) {
         S = "'" + S + "' (aka '" + akaStr + "')";
         return S;