[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

692

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

1077

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

1132

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

clang-tools-extra/clangd/Hover.h

35

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

692

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

169

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

[lh123]

clang-tools-extra/clangd/Hover.cpp

169

Should we set FullyQualifiedName printing policy for DesugaredTy.

[lh123]

clang-tools-extra/clangd/Hover.cpp

169

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

141–142

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

148

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

163

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

169

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.

169

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)

186

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

676

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

676

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

1075–1079

appendCode(llvm::to_string(ReturnType))

(from ScopedPrinter.h)

1254

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

50–51

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

clang/include/clang/AST/ASTDiagnostic.h

38 ↗

(On Diff #389968)

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

1254

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

1248

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

1254

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

1254

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

1254

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

struct HoverInfo {
   /// For example:
   /// - void foo(ParamType Name = DefaultValue)
   /// - #define FOO(Name)
   /// - template <ParamType Name = DefaultType> class Foo {};
   struct Param {
     /// The pretty-printed parameter type, e.g. "int", or "typename" (in
     /// TemplateParameters), might be None for macro parameters.
     llvm::Optional<std::string> Type;
+    /// CanonicalType
+    llvm::Optional<std::string> CanonicalType;
     /// 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:
struct HoverInfo {
   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.
   /// Set only for variables.
   llvm::Optional<std::string> Type;
+  /// CanonicalType
+  llvm::Optional<std::string> CanonicalType;
   /// Set for functions and lambdas.
   llvm::Optional<std::string> ReturnType;
+  /// Canonical retuen type
+  llvm::Optional<std::string> CanonicalReturnType;
   /// 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;

clang-tools-extra/clangd/Hover.cpp

 
 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) {
+std::string printType(QualType QT, const PrintingPolicy &PP,
+                      bool Canonical = false) {
   // 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();
+  if (Canonical && !QT.isNull()) {
+    QT = QT.getCanonicalType();
+  }
   QT.print(OS, PP);
   return Result;
 }
 
 std::string printType(const TemplateTypeParmDecl *TTP) {
   std::string Res = TTP->wasDeclaredWithTypename() ? "typename" : "class";
   if (TTP->isParameterPack())
     Res += "...";
   return Res;
 }
 
 std::string printType(const NonTypeTemplateParmDecl *NTTP,
-                      const PrintingPolicy &PP) {
-  std::string Res = printType(NTTP->getType(), PP);
+                      const PrintingPolicy &PP, bool Canonical = false) {
+  std::string Res = printType(NTTP->getType(), PP, Canonical);
   if (NTTP->isParameterPack())
     Res += "...";
   return Res;
 }
 
 std::string printType(const TemplateTemplateParmDecl *TTP,
-                      const PrintingPolicy &PP) {
+                      const PrintingPolicy &PP, bool Canonical = false) {
   std::string Res;
   llvm::raw_string_ostream OS(Res);
   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);
     else if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Param))
-      OS << printType(NTTP, PP);
+      OS << printType(NTTP, PP, Canonical);
     else if (const auto *TTPD = dyn_cast<TemplateTemplateParmDecl>(Param))
-      OS << printType(TTPD, PP);
+      OS << printType(TTPD, PP, Canonical);
   }
   // FIXME: TemplateTemplateParameter doesn't store the info on whether this
   // param was a "typename" or "class".
   OS << "> class";
   return OS.str();
 }
 
 std::vector<HoverInfo::Param>
if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(Param)) {
 
       if (!TTP->getName().empty())
         P.Name = TTP->getNameAsString();
 
       if (TTP->hasDefaultArgument())
         P.Default = TTP->getDefaultArgument().getAsString(PP);
     } else if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
       P.Type = printType(NTTP, PP);
+      P.CanonicalType = printType(NTTP, PP, true);
 
       if (IdentifierInfo *II = NTTP->getIdentifier())
         P.Name = II->getName().str();
 
       if (NTTP->hasDefaultArgument()) {
         P.Default.emplace();
         llvm::raw_string_ostream Out(*P.Default);
         NTTP->getDefaultArgument()->printPretty(Out, nullptr, PP);
       }
     } else if (const auto *TTPD = dyn_cast<TemplateTemplateParmDecl>(Param)) {
       P.Type = printType(TTPD, PP);
+      P.CanonicalType = printType(TTPD, PP, true);
 
       if (!TTPD->getName().empty())
         P.Name = TTPD->getNameAsString();
 
       if (TTPD->hasDefaultArgument()) {
         P.Default.emplace();
         llvm::raw_string_ostream Out(*P.Default);
         TTPD->getDefaultArgument().getArgument().print(PP, Out,
const Expr *getDefaultArg(const ParmVarDecl *PVD) {
   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.CanonicalType = printType(PVD->getType(), PP, true);
   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,
   // 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.CanonicalReturnType = printType(FD->getReturnType(), PP, true);
   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.CanonicalType = printType(QT, PP, true);
   // 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()) {
           fetchTemplateParameters(FTD->getTemplateParameters(), PP);
       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))
+  else if (const auto *VD = dyn_cast<ValueDecl>(D)) {
     HI.Type = printType(VD->getType(), PP);
-  else if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(D))
+    HI.CanonicalType = printType(VD->getType(), PP, true);
+  } 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.CanonicalType = HI.Type;
+  } else if (const auto *TTP = dyn_cast<TemplateTemplateParmDecl>(D)) {
     HI.Type = printType(TTP, PP);
+    HI.CanonicalType = printType(TTP, PP, true);
+  }
+    
 
   // 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())
llvm::Optional<HoverInfo> getThisExprHoverContents(const CXXThisExpr *CTE,
   // 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);
   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);
 
     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.CanonicalType = printType(E->getType(), PP, true);
     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 ReturnTypeStr = *ReturnType;
+    if (CanonicalReturnType && CanonicalReturnType != ReturnType) {
+      ReturnTypeStr += llvm::formatv(" (aka '{0}')", *CanonicalReturnType);
+    }
+    Output.addParagraph().appendText("→ ").appendCode(ReturnTypeStr);
     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 TypeStr = *Type;
+    if (CanonicalType && CanonicalType != Type) {
+      TypeStr += llvm::formatv(" (aka '{0}')", *CanonicalType);
+    }
+    Output.addParagraph().appendText("Type: ").appendCode(TypeStr);
   }
 
   if (Value) {
     markup::Paragraph &P = Output.addParagraph();
     P.appendText("Value = ");
     P.appendCode(*Value);
   }
 
if (CalleeArgInfo) {
     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 << ")";
+    if (CallPassType->Converted && CalleeArgInfo->Type) {
+      std::string ConvertedTypeStr = *CalleeArgInfo->Type;
+      if (CalleeArgInfo->CanonicalType &&
+          CalleeArgInfo->CanonicalType != CalleeArgInfo->Type) {
+        ConvertedTypeStr +=
+            llvm::formatv(" aka '{0}'", *CalleeArgInfo->CanonicalType);
+      }
+      OS << " (converted to " << ConvertedTypeStr << ")";
+    }
     Output.addParagraph().appendText(OS.str());
   }
 
   if (!Documentation.empty())
     parseDocumentation(Documentation, Output);
 
   if (!Definition.empty()) {
     Output.addRuler();
void parseDocumentation(llvm::StringRef Input, markup::Document &Output) {
   }
   FlushParagraph();
 }
 
 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);
   if (P.Name)
     Output.push_back(*P.Name);
   OS << llvm::join(Output, " ");
   if (P.Default)
     OS << " = " << *P.Default;
+  if (P.CanonicalType && P.CanonicalType != P.Type)
+    OS << llvm::formatv(" (aka '{0}')", *P.CanonicalType);
   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.CanonicalReturnType = "void";
          HI.Type = "void ()";
+         HI.CanonicalType = "void ()";
          HI.Parameters.emplace();
        }},
       // Inside namespace
       {R"cpp(
           namespace ns1 { namespace ns2 {
             /// Best foo ever.
             void [[fo^o]]() {}
           }}
           )cpp",
        [](HoverInfo &HI) {
          HI.NamespaceScope = "ns1::ns2::";
          HI.Name = "foo";
          HI.Kind = index::SymbolKind::Function;
          HI.Documentation = "Best foo ever.";
          HI.Definition = "void foo()";
          HI.ReturnType = "void";
+         HI.CanonicalReturnType = "void";
          HI.Type = "void ()";
+         HI.CanonicalType = "void ()";
          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.CanonicalType = "char";
          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.CanonicalType = "char";
          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.CanonicalType = "int";
          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.CanonicalType = "int";
        }},
       // 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.CanonicalType = "char";
          HI.Offset = 0;
          HI.Size = 1;
          HI.AccessSpecifier = "public";
        }},
       // Struct definition shows size.
       {R"cpp(
           struct [[^X]]{};
           )cpp",
const std::function<void(HoverInfo &)> ExpectedBuilder;
           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.CanonicalType = "Foo<int, char, bool>";
        }},
       // 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.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("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("typename"), std::string("typename"), llvm::None,
+              std::string("char")},
+             {std::string("int"), std::string("int"), llvm::None,
+              std::string("0")},
+             {std::string("bool"), std::string("bool"), std::string("Q"),
+              std::string("false")},
+             {std::string("class..."), std::string("class..."),
+              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.CanonicalReturnType = "void";
          HI.Type = "void ()";
+         HI.CanonicalType = "void ()";
          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.CanonicalReturnType = "Foo<bool, true, false>";
          HI.Type = "Foo<bool, true, false> (int, bool)";
+         HI.CanonicalType = "Foo<bool, true, false> (int, bool)";
          HI.Parameters = {
-             {std::string("int"), llvm::None, llvm::None},
-             {std::string("bool"), std::string("T"), std::string("false")},
+             {std::string("int"), std::string("int"), llvm::None, llvm::None},
+             {std::string("bool"), std::string("bool"), std::string("T"),
+              std::string("false")},
          };
        }},
       // Pointers to lambdas
       {R"cpp(
         void foo() {
           auto lamb = [](int T, bool B) -> bool { return T && B; };
           auto *b = &lamb;
           auto *[[^c]] = &b;
         }
         )cpp",
        [](HoverInfo &HI) {
          HI.NamespaceScope = "";
          HI.LocalScope = "foo::";
          HI.Name = "c";
          HI.Kind = index::SymbolKind::Variable;
          HI.Definition = "auto *c = &b";
          HI.Type = "(lambda) **";
+         HI.CanonicalType = "(lambda) **";
          HI.ReturnType = "bool";
+         HI.CanonicalReturnType = "bool";
          HI.Parameters = {
-             {std::string("int"), std::string("T"), llvm::None},
-             {std::string("bool"), std::string("B"), llvm::None},
+             {std::string("int"), std::string("int"), std::string("T"),
+              llvm::None},
+             {std::string("bool"), std::string("bool"), std::string("B"),
+              llvm::None},
          };
          return HI;
        }},
       // Lambda parameter with decltype reference
       {R"cpp(
         auto lamb = [](int T, bool B) -> bool { return T && B; };
         void foo(decltype(lamb)& bar) {
           [[ba^r]](0, false);
         }
         )cpp",
        [](HoverInfo &HI) {
          HI.NamespaceScope = "";
          HI.LocalScope = "foo::";
          HI.Name = "bar";
          HI.Kind = index::SymbolKind::Parameter;
          HI.Definition = "decltype(lamb) &bar";
          HI.Type = "decltype(lamb) &";
+         HI.CanonicalType = "(lambda) &";
          HI.ReturnType = "bool";
+         HI.CanonicalReturnType = "bool";
          HI.Parameters = {
-             {std::string("int"), std::string("T"), llvm::None},
-             {std::string("bool"), std::string("B"), llvm::None},
+             {std::string("int"), std::string("int"), std::string("T"),
+              llvm::None},
+             {std::string("bool"), std::string("bool"), std::string("B"),
+              llvm::None},
          };
          return HI;
        }},
       // Lambda parameter with decltype
       {R"cpp(
         auto lamb = [](int T, bool B) -> bool { return T && B; };
         void foo(decltype(lamb) bar) {
           [[ba^r]](0, false);
         }
         )cpp",
        [](HoverInfo &HI) {
          HI.NamespaceScope = "";
          HI.LocalScope = "foo::";
          HI.Name = "bar";
          HI.Kind = index::SymbolKind::Parameter;
          HI.Definition = "decltype(lamb) bar";
          HI.Type = "class (lambda)";
+         HI.CanonicalType = "class (lambda)";
          HI.ReturnType = "bool";
+         HI.CanonicalReturnType = "bool";
          HI.Parameters = {
-             {std::string("int"), std::string("T"), llvm::None},
-             {std::string("bool"), std::string("B"), llvm::None},
+             {std::string("int"), std::string("int"), std::string("T"),
+              llvm::None},
+             {std::string("bool"), std::string("bool"), std::string("B"),
+              llvm::None},
          };
          HI.Value = "false";
          return HI;
        }},
       // Lambda variable
       {R"cpp(
         void foo() {
           int bar = 5;
           auto lamb = [&bar](int T, bool B) -> bool { return T && B && bar; };
           bool res = [[lam^b]](bar, false);
         }
         )cpp",
        [](HoverInfo &HI) {
          HI.NamespaceScope = "";
          HI.LocalScope = "foo::";
          HI.Name = "lamb";
          HI.Kind = index::SymbolKind::Variable;
          HI.Definition = "auto lamb = [&bar](int T, bool B) -> bool {}";
          HI.Type = "class (lambda)";
+         HI.CanonicalType = "class (lambda)";
          HI.ReturnType = "bool";
+         HI.CanonicalReturnType = "bool";
          HI.Parameters = {
-             {std::string("int"), std::string("T"), llvm::None},
-             {std::string("bool"), std::string("B"), llvm::None},
+             {std::string("int"), std::string("int"), std::string("T"),
+              llvm::None},
+             {std::string("bool"), std::string("bool"), std::string("B"),
+              llvm::None},
          };
          return HI;
        }},
       // Local variable in lambda
       {R"cpp(
         void foo() {
           auto lamb = []{int [[te^st]];};
         }
         )cpp",
        [](HoverInfo &HI) {
          HI.NamespaceScope = "";
          HI.LocalScope = "foo::(anonymous class)::operator()::";
          HI.Name = "test";
          HI.Kind = index::SymbolKind::Variable;
          HI.Definition = "int test";
          HI.Type = "int";
+         HI.CanonicalType = "int";
        }},
       // Partially-specialized class template. (formerly type-parameter-0-0)
       {R"cpp(
         template <typename T> class X;
         template <typename T> class [[^X]]<T*> {};
         )cpp",
        [](HoverInfo &HI) {
          HI.Name = "X<T *>";
class Foo {})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.CanonicalType = "int";
          HI.NamespaceScope = "";
          HI.Value = "3";
        }},
       {R"cpp(
         int [[b^ar]] = sizeof(char);
         )cpp",
        [](HoverInfo &HI) {
          HI.Name = "bar";
          HI.Definition = "int bar = sizeof(char)";
          HI.Kind = index::SymbolKind::Variable;
          HI.Type = "int";
+         HI.CanonicalType = "int";
          HI.NamespaceScope = "";
          HI.Value = "1";
        }},
       {R"cpp(
         template<int a, int b> struct Add {
           static constexpr int result = a + b;
         };
         int [[ba^r]] = Add<1, 2>::result;
         )cpp",
        [](HoverInfo &HI) {
          HI.Name = "bar";
          HI.Definition = "int bar = Add<1, 2>::result";
          HI.Kind = index::SymbolKind::Variable;
          HI.Type = "int";
+         HI.CanonicalType = "int";
          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.CanonicalType = "enum Color";
          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.CanonicalType = "enum Color";
          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.CanonicalType = "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 ()";
+         HI.CanonicalType = "int ()";
+         HI.ReturnType = "my_int";
+         HI.CanonicalReturnType = "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.CanonicalType = "const char *";
          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.CanonicalType = "int";
          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";
           )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.CanonicalType = "typename";
          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.CanonicalType = "template <typename> class";
          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.CanonicalType = "int";
          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.CanonicalType = "float ()";
          HI.ReturnType = "float";
+         HI.CanonicalReturnType = "float";
          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.CanonicalType = "void (float)";
          HI.ReturnType = "void";
+         HI.CanonicalReturnType = "void";
          HI.Parameters.emplace();
          HI.Parameters->emplace_back();
          HI.Parameters->back().Type = "float";
+         HI.Parameters->back().CanonicalType = "float";
          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.CanonicalType = "X &(float)";
          HI.ReturnType = "X &";
+         HI.CanonicalReturnType = "X &";
          HI.Parameters.emplace();
          HI.Parameters->emplace_back();
          HI.Parameters->back().Type = "float";
+         HI.Parameters->back().CanonicalType = "float";
          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.CanonicalType = "void (float)";
          HI.ReturnType = "void";
+         HI.CanonicalReturnType = "void";
          HI.Parameters.emplace();
          HI.Parameters->emplace_back();
          HI.Parameters->back().Type = "float";
+         HI.Parameters->back().CanonicalType = "float";
          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.CanonicalType = "struct X";
        }},
       {// 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.CanonicalType = "NULL TYPE";
          // 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.CanonicalType = "int";
          HI.CalleeArgInfo.emplace();
          HI.CalleeArgInfo->Name = "arg_b";
          HI.CalleeArgInfo->Type = "int &";
          HI.CallPassType.emplace();
          HI.CallPassType->PassBy = PassMode::Ref;
          HI.CallPassType->Converted = false;
        }},
       {// Extra info for method call.
class Foo {})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.CanonicalType = "int";
          HI.CalleeArgInfo.emplace();
          HI.CalleeArgInfo->Name = "arg_a";
          HI.CalleeArgInfo->Type = "int";
          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.CanonicalType = "int";
          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.CanonicalType = "int";
          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.CanonicalType = "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";
+         HI.CanonicalType = "int";
        }}};
   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
for (const auto &Case : Cases) {
 
     EXPECT_EQ(H->NamespaceScope, Expected.NamespaceScope);
     EXPECT_EQ(H->LocalScope, Expected.LocalScope);
     EXPECT_EQ(H->Name, Expected.Name);
     EXPECT_EQ(H->Kind, Expected.Kind);
     EXPECT_EQ(H->Documentation, Expected.Documentation);
     EXPECT_EQ(H->Definition, Expected.Definition);
     EXPECT_EQ(H->Type, Expected.Type);
+    EXPECT_EQ(H->CanonicalType, Expected.CanonicalType);
     EXPECT_EQ(H->ReturnType, Expected.ReturnType);
+    EXPECT_EQ(H->CanonicalReturnType, Expected.CanonicalReturnType);
     EXPECT_EQ(H->Parameters, Expected.Parameters);
     EXPECT_EQ(H->TemplateParameters, Expected.TemplateParameters);
     EXPECT_EQ(H->SymRange, Expected.SymRange);
     EXPECT_EQ(H->Value, Expected.Value);
     EXPECT_EQ(H->Size, Expected.Size);
     EXPECT_EQ(H->Offset, Expected.Offset);
     EXPECT_EQ(H->AccessSpecifier, Expected.AccessSpecifier);
     EXPECT_EQ(H->CalleeArgInfo, Expected.CalleeArgInfo);
const std::function<void(HoverInfo &)> ExpectedBuilder;
             }
           )cpp",
           [](HoverInfo &HI) {
             HI.Name = "bonjour";
             HI.Kind = index::SymbolKind::Variable;
             HI.NamespaceScope = "";
             HI.LocalScope = "main::";
             HI.Type = "int";
+            HI.CanonicalType = "int";
             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.CanonicalType = "int";
             HI.Definition = "int bonjour";
           }},
       {
           R"cpp(// Struct
             namespace ns1 {
               struct MyClass {};
             } // namespace ns1
             int main() {
const std::function<void(HoverInfo &)> ExpectedBuilder;
               auto *X = &^[[foo]];
             }
           )cpp",
           [](HoverInfo &HI) {
             HI.Name = "foo";
             HI.Kind = index::SymbolKind::Function;
             HI.NamespaceScope = "";
             HI.Type = "void (int)";
+            HI.CanonicalType = "void (int)";
             HI.Definition = "void foo(int)";
             HI.Documentation = "Function definition via pointer";
             HI.ReturnType = "void";
+            HI.CanonicalReturnType = "void";
             HI.Parameters = {
-                {std::string("int"), llvm::None, llvm::None},
+                {std::string("int"), std::string("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.CanonicalType = "int (int)";
             HI.Definition = "int foo(int)";
             HI.Documentation = "Function declaration via call";
             HI.ReturnType = "int";
+            HI.CanonicalReturnType = "int";
             HI.Parameters = {
-                {std::string("int"), llvm::None, llvm::None},
+                {std::string("int"), std::string("int"), 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.CanonicalType = "int";
             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.CanonicalType = "int";
             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.CanonicalType = "int";
             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.CanonicalType = "int";
             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.CanonicalType = "int";
             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.CanonicalType = "int";
             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.CanonicalType = "int ()";
             HI.Definition = "int x()";
             HI.ReturnType = "int";
+            HI.CanonicalReturnType = "int";
             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.CanonicalType = "int ()";
             HI.Definition = "static int x()";
             HI.ReturnType = "int";
+            HI.CanonicalReturnType = "int";
             HI.Parameters = std::vector<HoverInfo::Param>{};
           }},
       {
           R"cpp(// Typedef
             typedef int Foo;
             int main() {
               ^[[Foo]] bar;
             }
const std::function<void(HoverInfo &)> ExpectedBuilder;
             } // 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.CanonicalType = "int";
             HI.Definition = "int foo";
           }},
       {
           R"cpp(// Macro
             #define MACRO 0
             int main() { return ^[[MACRO]]; }
           )cpp",
           [](HoverInfo &HI) {
const std::function<void(HoverInfo &)> ExpectedBuilder;
             void g() { [[f^oo]](); }
             void foo() {}
           )cpp",
           [](HoverInfo &HI) {
             HI.Name = "foo";
             HI.Kind = index::SymbolKind::Function;
             HI.NamespaceScope = "";
             HI.Type = "void ()";
+            HI.CanonicalType = "void ()";
             HI.Definition = "void foo()";
             HI.Documentation = "Function declaration";
             HI.ReturnType = "void";
+            HI.CanonicalReturnType = "void";
             HI.Parameters = std::vector<HoverInfo::Param>{};
           }},
       {
           R"cpp(// Enum declaration
             enum Hello {
               ONE, TWO, THREE,
             };
             void foo() {
const std::function<void(HoverInfo &)> ExpectedBuilder;
             }
           )cpp",
           [](HoverInfo &HI) {
             HI.Name = "ONE";
             HI.Kind = index::SymbolKind::EnumConstant;
             HI.NamespaceScope = "";
             HI.LocalScope = "Hello::";
             HI.Type = "enum Hello";
+            HI.CanonicalType = "enum Hello";
             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.CanonicalType = "enum (unnamed)";
             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.CanonicalType = "int";
             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.CanonicalType = "long long";
             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.CanonicalType = "int";
             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.CanonicalType = "int ()";
             HI.Definition = "template <> int foo<int>()";
             HI.Documentation = "Templated function";
             HI.ReturnType = "int";
+            HI.CanonicalReturnType = "int";
             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.CanonicalType = "int";
             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.CanonicalType = "void ()";
             HI.Definition = "void indexSymbol()";
             HI.ReturnType = "void";
+            HI.CanonicalReturnType = "void";
             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;
             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.CanonicalType = "Test &&";
             HI.Definition = "Test &&test = {}";
           }},
       {
           R"cpp(// auto on alias
           typedef int int_type;
           ^[[auto]] x = int_type();
           )cpp",
           [](HoverInfo &HI) {

           [](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.CanonicalReturnType = "int";
             HI.Type = "int ()";
+            HI.CanonicalType = "int ()";
           }},
       {
           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.CanonicalType = "cls<cls<cls<int>>>";
           }},
       {
           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.CanonicalType = "int";
           }},
       {
           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.CanonicalType = "int";
           }},
       {
           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.CanonicalType = "int";
           }},
       {
           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.CanonicalType = "int (int)";
             HI.ReturnType = "int";
+            HI.CanonicalReturnType = "int";
             HI.Parameters = {
-                {std::string("int"), std::string("x"), llvm::None}};
+                {std::string("int"), std::string("int"), 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.CanonicalType = "unsigned long";
             HI.Value = "1";
           }},
       {
           R"cpp(// alignof expr
           void foo() {
             (void)[[align^of]](char);
           })cpp",
           [](HoverInfo &HI) {
             HI.Name = "expression";
             HI.Type = "unsigned long";
+            HI.CanonicalType = "unsigned long";
             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.CanonicalType = "void (const int &)";
             HI.ReturnType = "void";
+            HI.CanonicalReturnType = "void";
             HI.Parameters = {
-                {std::string("const int &"), llvm::None, std::string("T()")}};
+                {std::string("const int &"), std::string("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
           )cpp",
           [](HoverInfo &HI) {
             HI.Name = "data";
             HI.Type = "char";
+            HI.CanonicalType = "char";
             HI.Kind = index::SymbolKind::Field;
             HI.LocalScope = "ObjC::";
             HI.NamespaceScope = "";
             HI.Definition = "char data";
           }},
       {
           R"cpp(
           @interface MYObject

         }
         @end
         )objc",
        [](HoverInfo &HI) {
          HI.Name = "result";
          HI.Definition = "int result = 2";
          HI.Kind = index::SymbolKind::Variable;
          HI.Type = "int";
+         HI.CanonicalType = "int";
          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.CanonicalType = "int";
          HI.LocalScope = "-[Foo variadicArgMethod:, ...]::";
          HI.NamespaceScope = "";
          HI.Value = "0";
        }},
       {R"cpp(
          void foo(int * __attribute__(([[non^null]], noescape)) );
          )cpp",
        [](HoverInfo &HI) {
for (const auto &Case : Cases) {
     SCOPED_TRACE(H->present().asPlainText());
     EXPECT_EQ(H->NamespaceScope, Expected.NamespaceScope);
     EXPECT_EQ(H->LocalScope, Expected.LocalScope);
     EXPECT_EQ(H->Name, Expected.Name);
     EXPECT_EQ(H->Kind, Expected.Kind);
     EXPECT_EQ(H->Documentation, Expected.Documentation);
     EXPECT_EQ(H->Definition, Expected.Definition);
     EXPECT_EQ(H->Type, Expected.Type);
+    EXPECT_EQ(H->CanonicalType, Expected.CanonicalType);
     EXPECT_EQ(H->ReturnType, Expected.ReturnType);
+    EXPECT_EQ(H->CanonicalReturnType, Expected.CanonicalReturnType);
     EXPECT_EQ(H->Parameters, Expected.Parameters);
     EXPECT_EQ(H->TemplateParameters, Expected.TemplateParameters);
     EXPECT_EQ(H->SymRange, Expected.SymRange);
     EXPECT_EQ(H->Value, Expected.Value);
   }
 }
 
 TEST(Hover, DocsFromIndex) {

 
 template <typename T, typename C = bool> class Foo {})",
       },
       {
           [](HoverInfo &HI) {
             HI.Kind = index::SymbolKind::Function;
             HI.Name = "foo";
             HI.Type = "type";
+            HI.CanonicalType = "c_type";
             HI.ReturnType = "ret_type";
+            HI.CanonicalReturnType = "can_ret_type";
             HI.Parameters.emplace();
             HoverInfo::Param P;
             HI.Parameters->push_back(P);
             P.Type = "type";
+            P.CanonicalType = "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.CanonicalType = "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";
+            HI.CanonicalReturnType = "unsigned long";
+            HI.Type = "size_t ()";
+            HI.CanonicalType = "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.CanonicalType = "int";
             HI.CalleeArgInfo.emplace();
             HI.CalleeArgInfo->Name = "arg_a";
             HI.CalleeArgInfo->Type = "int";
+            HI.CalleeArgInfo->CanonicalType = "int";
             HI.CalleeArgInfo->Default = "7";
             HI.CallPassType.emplace();
             HI.CallPassType->PassBy = PassMode::Value;
             HI.CallPassType->Converted = false;
           },
           R"(variable foo
 
 Type: int
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";
+            HI.CalleeArgInfo->CanonicalType = "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 aka 'int')
 
 // In test::Bar
 int foo = 3)",
       },
       {
           [](HoverInfo &HI) {
             HI.Kind = index::SymbolKind::Variable;
             HI.Name = "foo";