diff --git a/clang-tools-extra/clangd/AST.h b/clang-tools-extra/clangd/AST.h
--- a/clang-tools-extra/clangd/AST.h
+++ b/clang-tools-extra/clangd/AST.h
@@ -116,6 +116,11 @@
 // (i.e. vector<T*> rather than vector<type-parameter-0-0 *>.
 QualType declaredType(const TypeDecl *D);
 
+/// Retrieves the deduced type at a given location (auto, decltype).
+/// Retuns None unless Loc starts an auto/decltype token.
+/// It will return the underlying type.
+llvm::Optional<QualType> getDeducedType(ASTContext &, SourceLocation Loc);
+
 } // namespace clangd
 } // namespace clang
 
diff --git a/clang-tools-extra/clangd/AST.cpp b/clang-tools-extra/clangd/AST.cpp
--- a/clang-tools-extra/clangd/AST.cpp
+++ b/clang-tools-extra/clangd/AST.cpp
@@ -15,11 +15,13 @@
 #include "clang/AST/DeclarationName.h"
 #include "clang/AST/NestedNameSpecifier.h"
 #include "clang/AST/PrettyPrinter.h"
+#include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/AST/TemplateBase.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/Specifiers.h"
 #include "clang/Index/USRGeneration.h"
+#include "clang/Lex/Lexer.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/ScopedPrinter.h"
@@ -253,5 +255,114 @@
   return D->getASTContext().getTypeDeclType(D);
 }
 
+namespace {
+/// Computes the deduced type at a given location by visiting the relevant
+/// nodes. We use this to display the actual type when hovering over an "auto"
+/// keyword or "decltype()" expression.
+/// FIXME: This could have been a lot simpler by visiting AutoTypeLocs but it
+/// seems that the AutoTypeLocs that can be visited along with their AutoType do
+/// not have the deduced type set. Instead, we have to go to the appropriate
+/// DeclaratorDecl/FunctionDecl and work our back to the AutoType that does have
+/// a deduced type set. The AST should be improved to simplify this scenario.
+class DeducedTypeVisitor : public RecursiveASTVisitor<DeducedTypeVisitor> {
+  SourceLocation SearchedLocation;
+
+public:
+  DeducedTypeVisitor(SourceLocation SearchedLocation)
+      : SearchedLocation(SearchedLocation) {}
+
+  // Handle auto initializers:
+  //- auto i = 1;
+  //- decltype(auto) i = 1;
+  //- auto& i = 1;
+  //- auto* i = &a;
+  bool VisitDeclaratorDecl(DeclaratorDecl *D) {
+    if (!D->getTypeSourceInfo() ||
+        D->getTypeSourceInfo()->getTypeLoc().getBeginLoc() != SearchedLocation)
+      return true;
+
+    if (auto *AT = D->getType()->getContainedAutoType()) {
+      if (!AT->getDeducedType().isNull())
+        DeducedType = AT->getDeducedType();
+    }
+    return true;
+  }
+
+  // Handle auto return types:
+  //- auto foo() {}
+  //- auto& foo() {}
+  //- auto foo() -> int {}
+  //- auto foo() -> decltype(1+1) {}
+  //- operator auto() const { return 10; }
+  bool VisitFunctionDecl(FunctionDecl *D) {
+    if (!D->getTypeSourceInfo())
+      return true;
+    // Loc of auto in return type (c++14).
+    auto CurLoc = D->getReturnTypeSourceRange().getBegin();
+    // Loc of "auto" in operator auto()
+    if (CurLoc.isInvalid() && dyn_cast<CXXConversionDecl>(D))
+      CurLoc = D->getTypeSourceInfo()->getTypeLoc().getBeginLoc();
+    // Loc of "auto" in function with traling return type (c++11).
+    if (CurLoc.isInvalid())
+      CurLoc = D->getSourceRange().getBegin();
+    if (CurLoc != SearchedLocation)
+      return true;
+
+    const AutoType *AT = D->getReturnType()->getContainedAutoType();
+    if (AT && !AT->getDeducedType().isNull()) {
+      DeducedType = AT->getDeducedType();
+    } else if (auto DT = dyn_cast<DecltypeType>(D->getReturnType())) {
+      // auto in a trailing return type just points to a DecltypeType and
+      // getContainedAutoType does not unwrap it.
+      if (!DT->getUnderlyingType().isNull())
+        DeducedType = DT->getUnderlyingType();
+    } else if (!D->getReturnType().isNull()) {
+      DeducedType = D->getReturnType();
+    }
+    return true;
+  }
+
+  // Handle non-auto decltype, e.g.:
+  // - auto foo() -> decltype(expr) {}
+  // - decltype(expr);
+  bool VisitDecltypeTypeLoc(DecltypeTypeLoc TL) {
+    if (TL.getBeginLoc() != SearchedLocation)
+      return true;
+
+    // A DecltypeType's underlying type can be another DecltypeType! E.g.
+    //  int I = 0;
+    //  decltype(I) J = I;
+    //  decltype(J) K = J;
+    const DecltypeType *DT = dyn_cast<DecltypeType>(TL.getTypePtr());
+    while (DT && !DT->getUnderlyingType().isNull()) {
+      DeducedType = DT->getUnderlyingType();
+      DT = dyn_cast<DecltypeType>(DeducedType.getTypePtr());
+    }
+    return true;
+  }
+
+  QualType DeducedType;
+};
+} // namespace
+
+llvm::Optional<QualType> getDeducedType(ASTContext &ASTCtx,
+                                        SourceLocation Loc) {
+  Token Tok;
+  // Only try to find a deduced type if the token is auto or decltype.
+  if (!Loc.isValid() ||
+      Lexer::getRawToken(Loc, Tok, ASTCtx.getSourceManager(),
+                         ASTCtx.getLangOpts(), false) ||
+      !Tok.is(tok::raw_identifier) ||
+      !(Tok.getRawIdentifier() == "auto" ||
+        Tok.getRawIdentifier() == "decltype")) {
+    return {};
+  }
+  DeducedTypeVisitor V(Loc);
+  V.TraverseAST(ASTCtx);
+  if (V.DeducedType.isNull())
+    return llvm::None;
+  return V.DeducedType;
+}
+
 } // namespace clangd
 } // namespace clang
diff --git a/clang-tools-extra/clangd/CMakeLists.txt b/clang-tools-extra/clangd/CMakeLists.txt
--- a/clang-tools-extra/clangd/CMakeLists.txt
+++ b/clang-tools-extra/clangd/CMakeLists.txt
@@ -57,6 +57,7 @@
   GlobalCompilationDatabase.cpp
   Headers.cpp
   HeaderSourceSwitch.cpp
+  Hover.cpp
   IncludeFixer.cpp
   JSONTransport.cpp
   Logger.cpp
diff --git a/clang-tools-extra/clangd/ClangdServer.h b/clang-tools-extra/clangd/ClangdServer.h
--- a/clang-tools-extra/clangd/ClangdServer.h
+++ b/clang-tools-extra/clangd/ClangdServer.h
@@ -16,6 +16,7 @@
 #include "FormattedString.h"
 #include "Function.h"
 #include "GlobalCompilationDatabase.h"
+#include "Hover.h"
 #include "Protocol.h"
 #include "SemanticHighlighting.h"
 #include "TUScheduler.h"
diff --git a/clang-tools-extra/clangd/XRefs.h b/clang-tools-extra/clangd/XRefs.h
--- a/clang-tools-extra/clangd/XRefs.h
+++ b/clang-tools-extra/clangd/XRefs.h
@@ -53,77 +53,6 @@
 std::vector<DocumentHighlight> findDocumentHighlights(ParsedAST &AST,
                                                       Position Pos);
 
-/// 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 {
-  /// Represents parameters of a function, a template or a macro.
-  /// For example:
-  /// - void foo(ParamType Name = DefaultValue)
-  /// - #define FOO(Name)
-  /// - template <ParamType Name = DefaultType> class Foo {};
-  struct Param {
-    /// The pretty-printed parameter type, e.g. "int", or "typename" (in
-    /// TemplateParameters)
-    llvm::Optional<std::string> Type;
-    /// None for unnamed parameters.
-    llvm::Optional<std::string> Name;
-    /// None if no default is provided.
-    llvm::Optional<std::string> Default;
-  };
-
-  /// For a variable named Bar, declared in clang::clangd::Foo::getFoo the
-  /// following fields will hold:
-  /// - NamespaceScope: clang::clangd::
-  /// - LocalScope: Foo::getFoo::
-  /// - Name: Bar
-
-  /// Scopes might be None in cases where they don't make sense, e.g. macros and
-  /// auto/decltype.
-  /// Contains all of the enclosing namespaces, empty string means global
-  /// namespace.
-  llvm::Optional<std::string> NamespaceScope;
-  /// Remaining named contexts in symbol's qualified name, empty string means
-  /// symbol is not local.
-  std::string LocalScope;
-  /// Name of the symbol, does not contain any "::".
-  std::string Name;
-  llvm::Optional<Range> SymRange;
-  /// Scope containing the symbol. e.g, "global namespace", "function x::Y"
-  /// - None for deduced types, e.g "auto", "decltype" keywords.
-  SymbolKind Kind;
-  std::string Documentation;
-  /// Source code containing the definition of the symbol.
-  std::string Definition;
-
-  /// Pretty-printed variable type.
-  /// Set only for variables.
-  llvm::Optional<std::string> Type;
-  /// Set for functions and lambadas.
-  llvm::Optional<std::string> 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;
-
-  /// Produce a user-readable information.
-  FormattedString present() const;
-};
-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);
-
 /// Returns reference locations of the symbol at a specified \p Pos.
 /// \p Limit limits the number of results returned (0 means no limit).
 std::vector<Location> findReferences(ParsedAST &AST, Position Pos,
@@ -148,16 +77,6 @@
                           TypeHierarchyDirection Direction,
                           const SymbolIndex *Index);
 
-/// Retrieves the deduced type at a given location (auto, decltype).
-/// Retuns None unless SourceLocationBeg starts an auto/decltype token.
-/// It will return the underlying type.
-llvm::Optional<QualType> getDeducedType(ParsedAST &AST,
-                                        SourceLocation SourceLocationBeg);
-
-/// Check if there is a deduced type at a given location (auto, decltype).
-/// SourceLocationBeg must point to the first character of the token
-bool hasDeducedType(ParsedAST &AST, SourceLocation SourceLocationBeg);
-
 /// Returns all decls that are referenced in the \p FD except local symbols.
 llvm::DenseSet<const Decl *> getNonLocalDeclRefs(ParsedAST &AST,
                                                  const FunctionDecl *FD);
diff --git a/clang-tools-extra/clangd/XRefs.cpp b/clang-tools-extra/clangd/XRefs.cpp
--- a/clang-tools-extra/clangd/XRefs.cpp
+++ b/clang-tools-extra/clangd/XRefs.cpp
@@ -10,7 +10,6 @@
 #include "CodeCompletionStrings.h"
 #include "FindSymbols.h"
 #include "FindTarget.h"
-#include "FormattedString.h"
 #include "Logger.h"
 #include "ParsedAST.h"
 #include "Protocol.h"
@@ -20,15 +19,12 @@
 #include "index/Index.h"
 #include "index/Merge.h"
 #include "index/Relation.h"
-#include "index/SymbolCollector.h"
 #include "index/SymbolLocation.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/ExprCXX.h"
-#include "clang/AST/PrettyPrinter.h"
-#include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/AST/Type.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/SourceLocation.h"
@@ -44,7 +40,6 @@
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Casting.h"
-#include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
 
@@ -396,500 +391,6 @@
   return Result;
 }
 
-static PrintingPolicy printingPolicyForDecls(PrintingPolicy Base) {
-  PrintingPolicy Policy(Base);
-
-  Policy.AnonymousTagLocations = false;
-  Policy.TerseOutput = true;
-  Policy.PolishForDeclaration = true;
-  Policy.ConstantsAsWritten = true;
-  Policy.SuppressTagKeyword = false;
-
-  return Policy;
-}
-
-/// Given a declaration \p D, return a human-readable string representing the
-/// local scope in which it is declared, i.e. class(es) and method name. Returns
-/// an empty string if it is not local.
-static std::string getLocalScope(const Decl *D) {
-  std::vector<std::string> Scopes;
-  const DeclContext *DC = D->getDeclContext();
-  auto GetName = [](const TypeDecl *D) {
-    if (!D->getDeclName().isEmpty()) {
-      PrintingPolicy Policy = D->getASTContext().getPrintingPolicy();
-      Policy.SuppressScope = true;
-      return declaredType(D).getAsString(Policy);
-    }
-    if (auto RD = dyn_cast<RecordDecl>(D))
-      return ("(anonymous " + RD->getKindName() + ")").str();
-    return std::string("");
-  };
-  while (DC) {
-    if (const TypeDecl *TD = dyn_cast<TypeDecl>(DC))
-      Scopes.push_back(GetName(TD));
-    else if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(DC))
-      Scopes.push_back(FD->getNameAsString());
-    DC = DC->getParent();
-  }
-
-  return llvm::join(llvm::reverse(Scopes), "::");
-}
-
-/// Returns the human-readable representation for namespace containing the
-/// declaration \p D. Returns empty if it is contained global namespace.
-static std::string getNamespaceScope(const Decl *D) {
-  const DeclContext *DC = D->getDeclContext();
-
-  if (const TypeDecl *TD = dyn_cast<TypeDecl>(DC))
-    return getNamespaceScope(TD);
-  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(DC))
-    return getNamespaceScope(FD);
-  if (const NamedDecl *ND = dyn_cast<NamedDecl>(DC))
-    return ND->getQualifiedNameAsString();
-
-  return "";
-}
-
-static std::string printDefinition(const Decl *D) {
-  std::string Definition;
-  llvm::raw_string_ostream OS(Definition);
-  PrintingPolicy Policy =
-      printingPolicyForDecls(D->getASTContext().getPrintingPolicy());
-  Policy.IncludeTagDefinition = false;
-  Policy.SuppressTemplateArgsInCXXConstructors = true;
-  D->print(OS, Policy);
-  OS.flush();
-  return Definition;
-}
-
-static void printParams(llvm::raw_ostream &OS,
-                        const std::vector<HoverInfo::Param> &Params) {
-  for (size_t I = 0, E = Params.size(); I != E; ++I) {
-    if (I)
-      OS << ", ";
-    OS << Params.at(I);
-  }
-}
-
-static std::vector<HoverInfo::Param>
-fetchTemplateParameters(const TemplateParameterList *Params,
-                        const PrintingPolicy &PP) {
-  assert(Params);
-  std::vector<HoverInfo::Param> TempParameters;
-
-  for (const Decl *Param : *Params) {
-    HoverInfo::Param P;
-    P.Type.emplace();
-    if (const auto TTP = dyn_cast<TemplateTypeParmDecl>(Param)) {
-      P.Type = TTP->wasDeclaredWithTypename() ? "typename" : "class";
-      if (TTP->isParameterPack())
-        *P.Type += "...";
-
-      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)) {
-      if (IdentifierInfo *II = NTTP->getIdentifier())
-        P.Name = II->getName().str();
-
-      llvm::raw_string_ostream Out(*P.Type);
-      NTTP->getType().print(Out, PP);
-      if (NTTP->isParameterPack())
-        Out << "...";
-
-      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)) {
-      llvm::raw_string_ostream OS(*P.Type);
-      OS << "template <";
-      printParams(OS,
-                  fetchTemplateParameters(TTPD->getTemplateParameters(), PP));
-      OS << "> class"; // FIXME: TemplateTemplateParameter doesn't store the
-                       // info on whether this param was a "typename" or
-                       // "class".
-      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);
-      }
-    }
-    TempParameters.push_back(std::move(P));
-  }
-
-  return TempParameters;
-}
-
-static const FunctionDecl *getUnderlyingFunction(const Decl *D) {
-  // Extract lambda from variables.
-  if (const VarDecl *VD = llvm::dyn_cast<VarDecl>(D)) {
-    auto QT = VD->getType();
-    if (!QT.isNull()) {
-      while (!QT->getPointeeType().isNull())
-        QT = QT->getPointeeType();
-
-      if (const auto *CD = QT->getAsCXXRecordDecl())
-        return CD->getLambdaCallOperator();
-    }
-  }
-
-  // Non-lambda functions.
-  return D->getAsFunction();
-}
-
-// Look up information about D from the index, and add it to Hover.
-static void enhanceFromIndex(HoverInfo &Hover, const Decl *D,
-                             const SymbolIndex *Index) {
-  if (!Index || !llvm::isa<NamedDecl>(D))
-    return;
-  const NamedDecl &ND = *cast<NamedDecl>(D);
-  // We only add documentation, so don't bother if we already have some.
-  if (!Hover.Documentation.empty())
-    return;
-  // Skip querying for non-indexable symbols, there's no point.
-  // We're searching for symbols that might be indexed outside this main file.
-  if (!SymbolCollector::shouldCollectSymbol(ND, ND.getASTContext(),
-                                            SymbolCollector::Options(),
-                                            /*IsMainFileOnly=*/false))
-    return;
-  auto ID = getSymbolID(&ND);
-  if (!ID)
-    return;
-  LookupRequest Req;
-  Req.IDs.insert(*ID);
-  Index->lookup(
-      Req, [&](const Symbol &S) { Hover.Documentation = S.Documentation; });
-}
-
-// Populates Type, ReturnType, and Parameters for function-like decls.
-static void fillFunctionTypeAndParams(HoverInfo &HI, const Decl *D,
-                                      const FunctionDecl *FD,
-                                      const PrintingPolicy &Policy) {
-  HI.Parameters.emplace();
-  for (const ParmVarDecl *PVD : FD->parameters()) {
-    HI.Parameters->emplace_back();
-    auto &P = HI.Parameters->back();
-    if (!PVD->getType().isNull()) {
-      P.Type.emplace();
-      llvm::raw_string_ostream OS(*P.Type);
-      PVD->getType().print(OS, Policy);
-    } else {
-      std::string Param;
-      llvm::raw_string_ostream OS(Param);
-      PVD->dump(OS);
-      OS.flush();
-      elog("Got param with null type: {0}", Param);
-    }
-    if (!PVD->getName().empty())
-      P.Name = PVD->getNameAsString();
-    if (PVD->hasDefaultArg()) {
-      P.Default.emplace();
-      llvm::raw_string_ostream Out(*P.Default);
-      PVD->getDefaultArg()->printPretty(Out, nullptr, Policy);
-    }
-  }
-
-  if (const auto* CCD = llvm::dyn_cast<CXXConstructorDecl>(FD)) {
-    // Constructor's "return type" is the class type.
-    HI.ReturnType = declaredType(CCD->getParent()).getAsString(Policy);
-    // Don't provide any type for the constructor itself.
-  } else if (const auto* CDD = llvm::dyn_cast<CXXDestructorDecl>(FD)){
-    HI.ReturnType = "void";
-  } else {
-    HI.ReturnType = FD->getReturnType().getAsString(Policy);
-
-    QualType FunctionType = FD->getType();
-    if (const VarDecl *VD = llvm::dyn_cast<VarDecl>(D)) // Lambdas
-      FunctionType = VD->getType().getDesugaredType(D->getASTContext());
-    HI.Type = FunctionType.getAsString(Policy);
-  }
-  // FIXME: handle variadics.
-}
-
-/// Generate a \p Hover object given the declaration \p D.
-static HoverInfo getHoverContents(const Decl *D, const SymbolIndex *Index) {
-  HoverInfo HI;
-  const ASTContext &Ctx = D->getASTContext();
-
-  HI.NamespaceScope = getNamespaceScope(D);
-  if (!HI.NamespaceScope->empty())
-    HI.NamespaceScope->append("::");
-  HI.LocalScope = getLocalScope(D);
-  if (!HI.LocalScope.empty())
-    HI.LocalScope.append("::");
-
-  PrintingPolicy Policy = printingPolicyForDecls(Ctx.getPrintingPolicy());
-  if (const NamedDecl *ND = llvm::dyn_cast<NamedDecl>(D)) {
-    HI.Documentation = getDeclComment(Ctx, *ND);
-    HI.Name = printName(Ctx, *ND);
-  }
-
-  HI.Kind = indexSymbolKindToSymbolKind(index::getSymbolInfo(D).Kind);
-
-  // Fill in template params.
-  if (const TemplateDecl *TD = D->getDescribedTemplate()) {
-    HI.TemplateParameters =
-        fetchTemplateParameters(TD->getTemplateParameters(), Policy);
-    D = TD;
-  } else if (const FunctionDecl *FD = D->getAsFunction()) {
-    if (const auto FTD = FD->getDescribedTemplate()) {
-      HI.TemplateParameters =
-          fetchTemplateParameters(FTD->getTemplateParameters(), Policy);
-      D = FTD;
-    }
-  }
-
-  // Fill in types and params.
-  if (const FunctionDecl *FD = getUnderlyingFunction(D)) {
-    fillFunctionTypeAndParams(HI, D, FD, Policy);
-  } else if (const auto *VD = dyn_cast<ValueDecl>(D)) {
-    HI.Type.emplace();
-    llvm::raw_string_ostream OS(*HI.Type);
-    VD->getType().print(OS, Policy);
-  }
-
-  // Fill in value with evaluated initializer if possible.
-  // FIXME(kadircet): Also set Value field for expressions like "sizeof" and
-  // function calls.
-  if (const auto *Var = dyn_cast<VarDecl>(D)) {
-    if (const Expr *Init = Var->getInit()) {
-      Expr::EvalResult Result;
-      if (!Init->isValueDependent() && Init->EvaluateAsRValue(Result, Ctx)) {
-        HI.Value.emplace();
-        llvm::raw_string_ostream ValueOS(*HI.Value);
-        Result.Val.printPretty(ValueOS, const_cast<ASTContext &>(Ctx),
-                               Init->getType());
-      }
-    }
-  } 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 = ECD->getInitVal().toString(10);
-  }
-
-  HI.Definition = printDefinition(D);
-  enhanceFromIndex(HI, D, Index);
-  return HI;
-}
-
-/// Generate a \p Hover object given the type \p T.
-static HoverInfo getHoverContents(QualType T, const Decl *D, ASTContext &ASTCtx,
-                                  const SymbolIndex *Index) {
-  HoverInfo HI;
-  llvm::raw_string_ostream OS(HI.Name);
-  PrintingPolicy Policy = printingPolicyForDecls(ASTCtx.getPrintingPolicy());
-  T.print(OS, Policy);
-  OS.flush();
-
-  if (D) {
-    HI.Kind = indexSymbolKindToSymbolKind(index::getSymbolInfo(D).Kind);
-    enhanceFromIndex(HI, D, Index);
-  }
-  return HI;
-}
-
-/// Generate a \p Hover object given the macro \p MacroDecl.
-static HoverInfo getHoverContents(const DefinedMacro &Macro, ParsedAST &AST) {
-  HoverInfo HI;
-  SourceManager &SM = AST.getSourceManager();
-  HI.Name = Macro.Name;
-  HI.Kind = indexSymbolKindToSymbolKind(
-      index::getSymbolInfoForMacro(*Macro.Info).Kind);
-  // FIXME: Populate documentation
-  // FIXME: Pupulate parameters
-
-  // Try to get the full definition, not just the name
-  SourceLocation StartLoc = Macro.Info->getDefinitionLoc();
-  SourceLocation EndLoc = Macro.Info->getDefinitionEndLoc();
-  if (EndLoc.isValid()) {
-    EndLoc = Lexer::getLocForEndOfToken(EndLoc, 0, SM,
-                                        AST.getASTContext().getLangOpts());
-    bool Invalid;
-    StringRef Buffer = SM.getBufferData(SM.getFileID(StartLoc), &Invalid);
-    if (!Invalid) {
-      unsigned StartOffset = SM.getFileOffset(StartLoc);
-      unsigned EndOffset = SM.getFileOffset(EndLoc);
-      if (EndOffset <= Buffer.size() && StartOffset < EndOffset)
-        HI.Definition =
-            ("#define " + Buffer.substr(StartOffset, EndOffset - StartOffset))
-                .str();
-    }
-  }
-  return HI;
-}
-
-namespace {
-/// Computes the deduced type at a given location by visiting the relevant
-/// nodes. We use this to display the actual type when hovering over an "auto"
-/// keyword or "decltype()" expression.
-/// FIXME: This could have been a lot simpler by visiting AutoTypeLocs but it
-/// seems that the AutoTypeLocs that can be visited along with their AutoType do
-/// not have the deduced type set. Instead, we have to go to the appropriate
-/// DeclaratorDecl/FunctionDecl and work our back to the AutoType that does have
-/// a deduced type set. The AST should be improved to simplify this scenario.
-class DeducedTypeVisitor : public RecursiveASTVisitor<DeducedTypeVisitor> {
-  SourceLocation SearchedLocation;
-
-public:
-  DeducedTypeVisitor(SourceLocation SearchedLocation)
-      : SearchedLocation(SearchedLocation) {}
-
-  // Handle auto initializers:
-  //- auto i = 1;
-  //- decltype(auto) i = 1;
-  //- auto& i = 1;
-  //- auto* i = &a;
-  bool VisitDeclaratorDecl(DeclaratorDecl *D) {
-    if (!D->getTypeSourceInfo() ||
-        D->getTypeSourceInfo()->getTypeLoc().getBeginLoc() != SearchedLocation)
-      return true;
-
-    if (auto *AT = D->getType()->getContainedAutoType()) {
-      if (!AT->getDeducedType().isNull()) {
-        DeducedType = AT->getDeducedType();
-        this->D = D;
-      }
-    }
-    return true;
-  }
-
-  // Handle auto return types:
-  //- auto foo() {}
-  //- auto& foo() {}
-  //- auto foo() -> int {}
-  //- auto foo() -> decltype(1+1) {}
-  //- operator auto() const { return 10; }
-  bool VisitFunctionDecl(FunctionDecl *D) {
-    if (!D->getTypeSourceInfo())
-      return true;
-    // Loc of auto in return type (c++14).
-    auto CurLoc = D->getReturnTypeSourceRange().getBegin();
-    // Loc of "auto" in operator auto()
-    if (CurLoc.isInvalid() && dyn_cast<CXXConversionDecl>(D))
-      CurLoc = D->getTypeSourceInfo()->getTypeLoc().getBeginLoc();
-    // Loc of "auto" in function with traling return type (c++11).
-    if (CurLoc.isInvalid())
-      CurLoc = D->getSourceRange().getBegin();
-    if (CurLoc != SearchedLocation)
-      return true;
-
-    const AutoType *AT = D->getReturnType()->getContainedAutoType();
-    if (AT && !AT->getDeducedType().isNull()) {
-      DeducedType = AT->getDeducedType();
-      this->D = D;
-    } else if (auto DT = dyn_cast<DecltypeType>(D->getReturnType())) {
-      // auto in a trailing return type just points to a DecltypeType and
-      // getContainedAutoType does not unwrap it.
-      if (!DT->getUnderlyingType().isNull()) {
-        DeducedType = DT->getUnderlyingType();
-        this->D = D;
-      }
-    } else if (!D->getReturnType().isNull()) {
-      DeducedType = D->getReturnType();
-      this->D = D;
-    }
-    return true;
-  }
-
-  // Handle non-auto decltype, e.g.:
-  // - auto foo() -> decltype(expr) {}
-  // - decltype(expr);
-  bool VisitDecltypeTypeLoc(DecltypeTypeLoc TL) {
-    if (TL.getBeginLoc() != SearchedLocation)
-      return true;
-
-    // A DecltypeType's underlying type can be another DecltypeType! E.g.
-    //  int I = 0;
-    //  decltype(I) J = I;
-    //  decltype(J) K = J;
-    const DecltypeType *DT = dyn_cast<DecltypeType>(TL.getTypePtr());
-    while (DT && !DT->getUnderlyingType().isNull()) {
-      DeducedType = DT->getUnderlyingType();
-      D = DT->getAsTagDecl();
-      DT = dyn_cast<DecltypeType>(DeducedType.getTypePtr());
-    }
-    return true;
-  }
-
-  QualType DeducedType;
-  const Decl *D = nullptr;
-};
-} // namespace
-
-/// Retrieves the deduced type at a given location (auto, decltype).
-/// SourceLocationBeg must point to the first character of the token
-llvm::Optional<QualType> getDeducedType(ParsedAST &AST,
-                                        SourceLocation SourceLocationBeg) {
-  Token Tok;
-  auto &ASTCtx = AST.getASTContext();
-  // Only try to find a deduced type if the token is auto or decltype.
-  if (!SourceLocationBeg.isValid() ||
-      Lexer::getRawToken(SourceLocationBeg, Tok, ASTCtx.getSourceManager(),
-                         ASTCtx.getLangOpts(), false) ||
-      !Tok.is(tok::raw_identifier)) {
-    return {};
-  }
-  AST.getPreprocessor().LookUpIdentifierInfo(Tok);
-  if (!(Tok.is(tok::kw_auto) || Tok.is(tok::kw_decltype)))
-    return {};
-
-  DeducedTypeVisitor V(SourceLocationBeg);
-  V.TraverseAST(AST.getASTContext());
-  return V.DeducedType;
-}
-
-/// Retrieves the deduced type at a given location (auto, decltype).
-bool hasDeducedType(ParsedAST &AST, SourceLocation SourceLocationBeg) {
-  return (bool)getDeducedType(AST, SourceLocationBeg);
-}
-
-llvm::Optional<HoverInfo> getHover(ParsedAST &AST, Position Pos,
-                                   format::FormatStyle Style,
-                                   const SymbolIndex *Index) {
-  const SourceManager &SM = AST.getSourceManager();
-  llvm::Optional<HoverInfo> HI;
-  SourceLocation SourceLocationBeg = SM.getMacroArgExpandedLocation(
-      getBeginningOfIdentifier(Pos, SM, AST.getASTContext().getLangOpts()));
-
-  if (hasDeducedType(AST, SourceLocationBeg)) {
-    DeducedTypeVisitor V(SourceLocationBeg);
-    V.TraverseAST(AST.getASTContext());
-    if (!V.DeducedType.isNull())
-      HI = getHoverContents(V.DeducedType, V.D, AST.getASTContext(), Index);
-  }
-
-  if (!HI) {
-    if (auto M = locateMacroAt(SourceLocationBeg, AST.getPreprocessor())) {
-      HI = getHoverContents(*M, AST);
-    } else {
-      DeclRelationSet Relations =
-          DeclRelation::TemplatePattern | DeclRelation::Alias;
-      auto Decls = getDeclAtPosition(AST, SourceLocationBeg, Relations);
-      if (!Decls.empty())
-        HI = getHoverContents(Decls.front(), Index);
-    }
-  }
-
-  if (!HI)
-    return llvm::None;
-
-  auto Replacements = format::reformat(
-      Style, HI->Definition, tooling::Range(0, HI->Definition.size()));
-  if (auto Formatted =
-          tooling::applyAllReplacements(HI->Definition, Replacements))
-    HI->Definition = *Formatted;
-
-  HI->SymRange =
-      getTokenRange(AST.getASTContext().getSourceManager(),
-                    AST.getASTContext().getLangOpts(), SourceLocationBeg);
-  return HI;
-}
-
 std::vector<Location> findReferences(ParsedAST &AST, Position Pos,
                                      uint32_t Limit, const SymbolIndex *Index) {
   if (!Limit)
@@ -1250,44 +751,6 @@
   }
 }
 
-FormattedString HoverInfo::present() const {
-  FormattedString Output;
-  if (NamespaceScope) {
-    Output.appendText("Declared in");
-    // Drop trailing "::".
-    if (!LocalScope.empty())
-      Output.appendInlineCode(llvm::StringRef(LocalScope).drop_back(2));
-    else if (NamespaceScope->empty())
-      Output.appendInlineCode("global namespace");
-    else
-      Output.appendInlineCode(llvm::StringRef(*NamespaceScope).drop_back(2));
-  }
-
-  if (!Definition.empty()) {
-    Output.appendCodeBlock(Definition);
-  } else {
-    // Builtin types
-    Output.appendCodeBlock(Name);
-  }
-
-  if (!Documentation.empty())
-    Output.appendText(Documentation);
-  return Output;
-}
-
-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;
-  return OS;
-}
-
 llvm::DenseSet<const Decl *> getNonLocalDeclRefs(ParsedAST &AST,
                                                  const FunctionDecl *FD) {
   if (!FD->hasBody())
diff --git a/clang-tools-extra/clangd/refactor/tweaks/ExpandAutoType.cpp b/clang-tools-extra/clangd/refactor/tweaks/ExpandAutoType.cpp
--- a/clang-tools-extra/clangd/refactor/tweaks/ExpandAutoType.cpp
+++ b/clang-tools-extra/clangd/refactor/tweaks/ExpandAutoType.cpp
@@ -74,10 +74,10 @@
   auto& SrcMgr = Inputs.AST.getASTContext().getSourceManager();
 
   llvm::Optional<clang::QualType> DeducedType =
-      getDeducedType(Inputs.AST, CachedLocation->getBeginLoc());
+      getDeducedType(Inputs.AST.getASTContext(), CachedLocation->getBeginLoc());
 
   // if we can't resolve the type, return an error message
-  if (DeducedType == llvm::None || DeducedType->isNull()) {
+  if (DeducedType == llvm::None) {
     return createErrorMessage("Could not deduce type for 'auto' type", Inputs);
   }
 
diff --git a/clang-tools-extra/clangd/unittests/ASTTests.cpp b/clang-tools-extra/clangd/unittests/ASTTests.cpp
--- a/clang-tools-extra/clangd/unittests/ASTTests.cpp
+++ b/clang-tools-extra/clangd/unittests/ASTTests.cpp
@@ -7,13 +7,18 @@
 //===----------------------------------------------------------------------===//
 
 #include "AST.h"
+
+#include "Annotations.h"
+#include "TestTU.h"
+
+#include "clang/Basic/SourceManager.h"
 #include "gtest/gtest.h"
 
 namespace clang {
 namespace clangd {
 namespace {
 
-TEST(ExpandAutoType, ShortenNamespace) {
+TEST(ShortenNamespace, All) {
   ASSERT_EQ("TestClass", shortenNamespace("TestClass", ""));
 
   ASSERT_EQ("TestClass", shortenNamespace(
@@ -36,6 +41,30 @@
                 "testns1::TestClass<testns1::OtherClass>", "testns1"));
 }
 
+TEST(GetDeducedType, KwAutoExpansion) {
+  struct Test {
+    StringRef AnnotatedCode;
+    const char *DeducedType;
+  } Tests[] = {
+      {"^auto i = 0;", "int"},
+      {"^auto f(){ return 1;};", "int"},
+  };
+  for (Test T : Tests) {
+    Annotations File(T.AnnotatedCode);
+    auto AST = TestTU::withCode(File.code()).build();
+    ASSERT_TRUE(AST.getDiagnostics().empty())
+        << AST.getDiagnostics().begin()->Message;
+    SourceManagerForFile SM("foo.cpp", File.code());
+
+    for (Position Pos : File.points()) {
+      auto Location = sourceLocationInMainFile(SM.get(), Pos);
+      ASSERT_TRUE(!!Location) << llvm::toString(Location.takeError());
+      auto DeducedType = getDeducedType(AST.getASTContext(), *Location);
+      EXPECT_EQ(DeducedType->getAsString(), T.DeducedType);
+    }
+  }
+}
+
 } // namespace
 } // namespace clangd
 } // namespace clang
diff --git a/clang-tools-extra/clangd/unittests/CMakeLists.txt b/clang-tools-extra/clangd/unittests/CMakeLists.txt
--- a/clang-tools-extra/clangd/unittests/CMakeLists.txt
+++ b/clang-tools-extra/clangd/unittests/CMakeLists.txt
@@ -47,6 +47,7 @@
   GlobalCompilationDatabaseTests.cpp
   HeadersTests.cpp
   HeaderSourceSwitchTests.cpp
+  HoverTests.cpp
   IndexActionTests.cpp
   IndexTests.cpp
   JSONTransportTests.cpp
diff --git a/clang-tools-extra/clangd/unittests/XRefsTests.cpp b/clang-tools-extra/clangd/unittests/XRefsTests.cpp
--- a/clang-tools-extra/clangd/unittests/XRefsTests.cpp
+++ b/clang-tools-extra/clangd/unittests/XRefsTests.cpp
@@ -603,1298 +603,6 @@
                               HeaderNotInPreambleAnnotations.range())));
 }
 
-TEST(Hover, Structured) {
-  struct {
-    const char *const Code;
-    const std::function<void(HoverInfo &)> ExpectedBuilder;
-  } Cases[] = {
-      // Global scope.
-      {R"cpp(
-          // Best foo ever.
-          void [[fo^o]]() {}
-          )cpp",
-       [](HoverInfo &HI) {
-         HI.NamespaceScope = "";
-         HI.Name = "foo";
-         HI.Kind = SymbolKind::Function;
-         HI.Documentation = "Best foo ever.";
-         HI.Definition = "void foo()";
-         HI.ReturnType = "void";
-         HI.Type = "void ()";
-         HI.Parameters.emplace();
-       }},
-      // Inside namespace
-      {R"cpp(
-          namespace ns1 { namespace ns2 {
-            /// Best foo ever.
-            void [[fo^o]]() {}
-          }}
-          )cpp",
-       [](HoverInfo &HI) {
-         HI.NamespaceScope = "ns1::ns2::";
-         HI.Name = "foo";
-         HI.Kind = SymbolKind::Function;
-         HI.Documentation = "Best foo ever.";
-         HI.Definition = "void foo()";
-         HI.ReturnType = "void";
-         HI.Type = "void ()";
-         HI.Parameters.emplace();
-       }},
-      // Field
-      {R"cpp(
-          namespace ns1 { namespace ns2 {
-            struct Foo {
-              int [[b^ar]];
-            };
-          }}
-          )cpp",
-       [](HoverInfo &HI) {
-         HI.NamespaceScope = "ns1::ns2::";
-         HI.LocalScope = "Foo::";
-         HI.Name = "bar";
-         HI.Kind = SymbolKind::Field;
-         HI.Definition = "int bar";
-         HI.Type = "int";
-       }},
-      // Local to class method.
-      {R"cpp(
-          namespace ns1 { namespace ns2 {
-            struct Foo {
-              void foo() {
-                int [[b^ar]];
-              }
-            };
-          }}
-          )cpp",
-       [](HoverInfo &HI) {
-         HI.NamespaceScope = "ns1::ns2::";
-         HI.LocalScope = "Foo::foo::";
-         HI.Name = "bar";
-         HI.Kind = SymbolKind::Variable;
-         HI.Definition = "int bar";
-         HI.Type = "int";
-       }},
-      // Anon namespace and local scope.
-      {R"cpp(
-          namespace ns1 { namespace {
-            struct {
-              int [[b^ar]];
-            } T;
-          }}
-          )cpp",
-       [](HoverInfo &HI) {
-         HI.NamespaceScope = "ns1::(anonymous)::";
-         HI.LocalScope = "(anonymous struct)::";
-         HI.Name = "bar";
-         HI.Kind = SymbolKind::Field;
-         HI.Definition = "int bar";
-         HI.Type = "int";
-       }},
-      // Variable with template type
-      {R"cpp(
-          template <typename T, class... Ts> class Foo { public: Foo(int); };
-          Foo<int, char, bool> [[fo^o]] = Foo<int, char, bool>(5);
-          )cpp",
-       [](HoverInfo &HI) {
-         HI.NamespaceScope = "";
-         HI.Name = "foo";
-         HI.Kind = SymbolKind::Variable;
-         HI.Definition = "Foo<int, char, bool> foo = Foo<int, char, bool>(5)";
-         HI.Type = "Foo<int, char, bool>";
-       }},
-      // Implicit template instantiation
-      {R"cpp(
-          template <typename T> class vector{};
-          [[vec^tor]]<int> foo;
-          )cpp",
-       [](HoverInfo &HI) {
-         HI.NamespaceScope = "";
-         HI.Name = "vector";
-         HI.Kind = SymbolKind::Class;
-         HI.Definition = "template <typename T> class vector {}";
-         HI.TemplateParameters = {
-             {std::string("typename"), std::string("T"), llvm::None},
-         };
-       }},
-      // Class template
-      {R"cpp(
-          template <template<typename, bool...> class C,
-                    typename = char,
-                    int = 0,
-                    bool Q = false,
-                    class... Ts> class Foo {};
-          template <template<typename, bool...> class T>
-          [[F^oo]]<T> foo;
-          )cpp",
-       [](HoverInfo &HI) {
-         HI.NamespaceScope = "";
-         HI.Name = "Foo";
-         HI.Kind = SymbolKind::Class;
-         HI.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},
-         };
-       }},
-      // 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 = SymbolKind::Function;
-         HI.Definition =
-             R"cpp(template <template <typename, bool...> class C, typename = char, int = 0,
-          bool Q = false, class... Ts>
-void foo())cpp";
-         HI.ReturnType = "void";
-         HI.Type = "void ()";
-         HI.Parameters.emplace();
-         HI.TemplateParameters = {
-             {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},
-         };
-       }},
-      // 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 = SymbolKind::Function;
-         HI.Definition = "Foo<bool, true, false> foo(int, bool T = false)";
-         HI.ReturnType = "Foo<bool, true, false>";
-         HI.Type = "Foo<bool, true, false> (int, bool)";
-         HI.Parameters = {
-             {std::string("int"), llvm::None, llvm::None},
-             {std::string("bool"), std::string("T"), std::string("false")},
-         };
-       }},
-      // Pointers to lambdas
-      {R"cpp(
-        void foo() {
-          auto lamb = [](int T, bool B) -> bool { return T && B; };
-          auto *b = &lamb;
-          auto *[[^c]] = &b;
-        }
-        )cpp",
-       [](HoverInfo &HI) {
-         HI.NamespaceScope = "";
-         HI.LocalScope = "foo::";
-         HI.Name = "c";
-         HI.Kind = SymbolKind::Variable;
-         HI.Definition = "auto *c = &b";
-         HI.Type = "class (lambda) **";
-         HI.ReturnType = "bool";
-         HI.Parameters = {
-             {std::string("int"), std::string("T"), llvm::None},
-             {std::string("bool"), std::string("B"), llvm::None},
-         };
-         return HI;
-       }},
-      // Lambda parameter with decltype reference
-      {R"cpp(
-        auto lamb = [](int T, bool B) -> bool { return T && B; };
-        void foo(decltype(lamb)& bar) {
-          [[ba^r]](0, false);
-        }
-        )cpp",
-       [](HoverInfo &HI) {
-         HI.NamespaceScope = "";
-         HI.LocalScope = "foo::";
-         HI.Name = "bar";
-         HI.Kind = SymbolKind::Variable;
-         HI.Definition = "decltype(lamb) &bar";
-         HI.Type = "decltype(lamb) &";
-         HI.ReturnType = "bool";
-         HI.Parameters = {
-             {std::string("int"), std::string("T"), llvm::None},
-             {std::string("bool"), std::string("B"), llvm::None},
-         };
-         return HI;
-       }},
-      // Lambda parameter with decltype
-      {R"cpp(
-        auto lamb = [](int T, bool B) -> bool { return T && B; };
-        void foo(decltype(lamb) bar) {
-          [[ba^r]](0, false);
-        }
-        )cpp",
-       [](HoverInfo &HI) {
-         HI.NamespaceScope = "";
-         HI.LocalScope = "foo::";
-         HI.Name = "bar";
-         HI.Kind = SymbolKind::Variable;
-         HI.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},
-         };
-         return HI;
-       }},
-      // Lambda variable
-      {R"cpp(
-        void foo() {
-          int bar = 5;
-          auto lamb = [&bar](int T, bool B) -> bool { return T && B && bar; };
-          bool res = [[lam^b]](bar, false);
-        }
-        )cpp",
-       [](HoverInfo &HI) {
-         HI.NamespaceScope = "";
-         HI.LocalScope = "foo::";
-         HI.Name = "lamb";
-         HI.Kind = SymbolKind::Variable;
-         HI.Definition = "auto lamb = [&bar](int T, bool B) -> bool {}";
-         HI.Type = "class (lambda)";
-         HI.ReturnType = "bool";
-         HI.Parameters = {
-             {std::string("int"), std::string("T"), llvm::None},
-             {std::string("bool"), std::string("B"), llvm::None},
-         };
-         return HI;
-       }},
-      // Local variable in lambda
-      {R"cpp(
-        void foo() {
-          auto lamb = []{int [[te^st]];};
-        }
-        )cpp",
-       [](HoverInfo &HI) {
-         HI.NamespaceScope = "";
-         HI.LocalScope = "foo::(anonymous class)::operator()::";
-         HI.Name = "test";
-         HI.Kind = SymbolKind::Variable;
-         HI.Definition = "int test";
-         HI.Type = "int";
-       }},
-      // Partially-specialized class template. (formerly type-parameter-0-0)
-      {R"cpp(
-        template <typename T> class X;
-        template <typename T> class [[^X]]<T*> {};
-        )cpp",
-       [](HoverInfo &HI) {
-         HI.Name = "X<T *>";
-         HI.NamespaceScope = "";
-         HI.Kind = SymbolKind::Class;
-         HI.Definition = "template <typename T> class X<T *> {}";
-       }},
-      // Constructor of partially-specialized class template
-      {R"cpp(
-          template<typename> struct X;
-          template<typename T> struct X<T*>{ [[^X]](); };
-          )cpp",
-       [](HoverInfo &HI) {
-         HI.NamespaceScope = "";
-         HI.Name = "X";
-         HI.LocalScope = "X<T *>::";
-         HI.Kind = SymbolKind::Constructor;
-         HI.ReturnType = "X<T *>";
-         HI.Definition = "X()";
-         HI.Parameters.emplace();
-       }},
-
-      // auto on lambda
-      {R"cpp(
-        void foo() {
-          [[au^to]] lamb = []{};
-        }
-        )cpp",
-       [](HoverInfo &HI) {
-         HI.Name = "class (lambda)";
-         HI.Kind = SymbolKind::Variable;
-       }},
-      // auto on template instantiation
-      {R"cpp(
-        template<typename T> class Foo{};
-        void foo() {
-          [[au^to]] x = Foo<int>();
-        }
-        )cpp",
-       [](HoverInfo &HI) {
-         HI.Name = "class Foo<int>";
-         HI.Kind = SymbolKind::Variable;
-       }},
-      // auto on specialized template
-      {R"cpp(
-        template<typename T> class Foo{};
-        template<> class Foo<int>{};
-        void foo() {
-          [[au^to]] x = Foo<int>();
-        }
-        )cpp",
-       [](HoverInfo &HI) {
-         HI.Name = "class Foo<int>";
-         HI.Kind = SymbolKind::Variable;
-       }},
-
-      // macro
-      {R"cpp(
-        // Best MACRO ever.
-        #define MACRO(x,y,z) void foo(x, y, z);
-        [[MAC^RO]](int, double d, bool z = false);
-        )cpp",
-       [](HoverInfo &HI) {
-         HI.Name = "MACRO", HI.Kind = SymbolKind::String,
-         HI.Definition = "#define MACRO(x, y, z) void foo(x, y, z);";
-       }},
-
-      // constexprs
-      {R"cpp(
-        constexpr int add(int a, int b) { return a + b; }
-        int [[b^ar]] = add(1, 2);
-        )cpp",
-       [](HoverInfo &HI) {
-         HI.Name = "bar";
-         HI.Definition = "int bar = add(1, 2)";
-         HI.Kind = SymbolKind::Variable;
-         HI.Type = "int";
-         HI.NamespaceScope = "";
-         HI.Value = "3";
-       }},
-      {R"cpp(
-        int [[b^ar]] = sizeof(char);
-        )cpp",
-       [](HoverInfo &HI) {
-         HI.Name = "bar";
-         HI.Definition = "int bar = sizeof(char)";
-         HI.Kind = SymbolKind::Variable;
-         HI.Type = "int";
-         HI.NamespaceScope = "";
-         HI.Value = "1";
-       }},
-      {R"cpp(
-        template<int a, int b> struct Add {
-          static constexpr int result = a + b;
-        };
-        int [[ba^r]] = Add<1, 2>::result;
-        )cpp",
-       [](HoverInfo &HI) {
-         HI.Name = "bar";
-         HI.Definition = "int bar = Add<1, 2>::result";
-         HI.Kind = SymbolKind::Variable;
-         HI.Type = "int";
-         HI.NamespaceScope = "";
-         HI.Value = "3";
-       }},
-      {R"cpp(
-        enum Color { RED, GREEN, };
-        Color x = [[GR^EEN]];
-       )cpp",
-       [](HoverInfo &HI) {
-         HI.Name = "GREEN";
-         HI.NamespaceScope = "";
-         HI.LocalScope = "Color::";
-         HI.Definition = "GREEN";
-         HI.Kind = SymbolKind::EnumMember;
-         HI.Type = "enum Color";
-         HI.Value = "1";
-       }},
-      // FIXME: We should use the Decl referenced, even if from an implicit
-      // instantiation. Then the scope would be Add<1, 2> and the value 3.
-      {R"cpp(
-        template<int a, int b> struct Add {
-          static constexpr int result = a + b;
-        };
-        int bar = Add<1, 2>::[[resu^lt]];
-        )cpp",
-       [](HoverInfo &HI) {
-         HI.Name = "result";
-         HI.Definition = "static constexpr int result = a + b";
-         HI.Kind = SymbolKind::Property;
-         HI.Type = "const int";
-         HI.NamespaceScope = "";
-         HI.LocalScope = "Add<a, b>::";
-       }},
-      {R"cpp(
-        const char *[[ba^r]] = "1234";
-        )cpp",
-       [](HoverInfo &HI) {
-         HI.Name = "bar";
-         HI.Definition = "const char *bar = \"1234\"";
-         HI.Kind = SymbolKind::Variable;
-         HI.Type = "const char *";
-         HI.NamespaceScope = "";
-         HI.Value = "&\"1234\"[0]";
-       }},
-  };
-  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");
-    auto AST = TU.build();
-    ASSERT_TRUE(AST.getDiagnostics().empty());
-
-    auto H = getHover(AST, T.point(), format::getLLVMStyle(), nullptr);
-    ASSERT_TRUE(H);
-    HoverInfo Expected;
-    Expected.SymRange = T.range();
-    Case.ExpectedBuilder(Expected);
-
-    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->ReturnType, Expected.ReturnType);
-    EXPECT_EQ(H->Parameters, Expected.Parameters);
-    EXPECT_EQ(H->TemplateParameters, Expected.TemplateParameters);
-    EXPECT_EQ(H->SymRange, Expected.SymRange);
-    EXPECT_EQ(H->Value, Expected.Value);
-  }
-} // namespace clang
-
-TEST(Hover, All) {
-  struct OneTest {
-    StringRef Input;
-    StringRef ExpectedHover;
-  };
-
-  OneTest Tests[] = {
-      {
-          R"cpp(// No hover
-            ^int main() {
-            }
-          )cpp",
-          "",
-      },
-      {
-          R"cpp(// Local variable
-            int main() {
-              int bonjour;
-              ^bonjour = 2;
-              int test1 = bonjour;
-            }
-          )cpp",
-          "text[Declared in]code[main]\n"
-          "codeblock(cpp) [\n"
-          "int bonjour\n"
-          "]",
-      },
-      {
-          R"cpp(// Local variable in method
-            struct s {
-              void method() {
-                int bonjour;
-                ^bonjour = 2;
-              }
-            };
-          )cpp",
-          "text[Declared in]code[s::method]\n"
-          "codeblock(cpp) [\n"
-          "int bonjour\n"
-          "]",
-      },
-      {
-          R"cpp(// Struct
-            namespace ns1 {
-              struct MyClass {};
-            } // namespace ns1
-            int main() {
-              ns1::My^Class* Params;
-            }
-          )cpp",
-          "text[Declared in]code[ns1]\n"
-          "codeblock(cpp) [\n"
-          "struct MyClass {}\n"
-          "]",
-      },
-      {
-          R"cpp(// Class
-            namespace ns1 {
-              class MyClass {};
-            } // namespace ns1
-            int main() {
-              ns1::My^Class* Params;
-            }
-          )cpp",
-          "text[Declared in]code[ns1]\n"
-          "codeblock(cpp) [\n"
-          "class MyClass {}\n"
-          "]",
-      },
-      {
-          R"cpp(// Union
-            namespace ns1 {
-              union MyUnion { int x; int y; };
-            } // namespace ns1
-            int main() {
-              ns1::My^Union Params;
-            }
-          )cpp",
-          "text[Declared in]code[ns1]\n"
-          "codeblock(cpp) [\n"
-          "union MyUnion {}\n"
-          "]",
-      },
-      {
-          R"cpp(// Function definition via pointer
-            int foo(int) {}
-            int main() {
-              auto *X = &^foo;
-            }
-          )cpp",
-          "text[Declared in]code[global namespace]\n"
-          "codeblock(cpp) [\n"
-          "int foo(int)\n"
-          "]\n"
-          "text[Function definition via pointer]",
-      },
-      {
-          R"cpp(// Function declaration via call
-            int foo(int);
-            int main() {
-              return ^foo(42);
-            }
-          )cpp",
-          "text[Declared in]code[global namespace]\n"
-          "codeblock(cpp) [\n"
-          "int foo(int)\n"
-          "]\n"
-          "text[Function declaration via call]",
-      },
-      {
-          R"cpp(// Field
-            struct Foo { int x; };
-            int main() {
-              Foo bar;
-              bar.^x;
-            }
-          )cpp",
-          "text[Declared in]code[Foo]\n"
-          "codeblock(cpp) [\n"
-          "int x\n"
-          "]",
-      },
-      {
-          R"cpp(// Field with initialization
-            struct Foo { int x = 5; };
-            int main() {
-              Foo bar;
-              bar.^x;
-            }
-          )cpp",
-          "text[Declared in]code[Foo]\n"
-          "codeblock(cpp) [\n"
-          "int x = 5\n"
-          "]",
-      },
-      {
-          R"cpp(// Static field
-            struct Foo { static int x; };
-            int main() {
-              Foo::^x;
-            }
-          )cpp",
-          "text[Declared in]code[Foo]\n"
-          "codeblock(cpp) [\n"
-          "static int x\n"
-          "]",
-      },
-      {
-          R"cpp(// Field, member initializer
-            struct Foo {
-              int x;
-              Foo() : ^x(0) {}
-            };
-          )cpp",
-          "text[Declared in]code[Foo]\n"
-          "codeblock(cpp) [\n"
-          "int x\n"
-          "]",
-      },
-      {
-          R"cpp(// Field, GNU old-style field designator
-            struct Foo { int x; };
-            int main() {
-              Foo bar = { ^x : 1 };
-            }
-          )cpp",
-          "text[Declared in]code[Foo]\n"
-          "codeblock(cpp) [\n"
-          "int x\n"
-          "]",
-      },
-      {
-          R"cpp(// Field, field designator
-            struct Foo { int x; };
-            int main() {
-              Foo bar = { .^x = 2 };
-            }
-          )cpp",
-          "text[Declared in]code[Foo]\n"
-          "codeblock(cpp) [\n"
-          "int x\n"
-          "]",
-      },
-      {
-          R"cpp(// Method call
-            struct Foo { int x(); };
-            int main() {
-              Foo bar;
-              bar.^x();
-            }
-          )cpp",
-          "text[Declared in]code[Foo]\n"
-          "codeblock(cpp) [\n"
-          "int x()\n"
-          "]",
-      },
-      {
-          R"cpp(// Static method call
-            struct Foo { static int x(); };
-            int main() {
-              Foo::^x();
-            }
-          )cpp",
-          "text[Declared in]code[Foo]\n"
-          "codeblock(cpp) [\n"
-          "static int x()\n"
-          "]",
-      },
-      {
-          R"cpp(// Typedef
-            typedef int Foo;
-            int main() {
-              ^Foo bar;
-            }
-          )cpp",
-          "text[Declared in]code[global namespace]\n"
-          "codeblock(cpp) [\n"
-          "typedef int Foo\n"
-          "]\n"
-          "text[Typedef]",
-      },
-      {
-          R"cpp(// Namespace
-            namespace ns {
-            struct Foo { static void bar(); }
-            } // namespace ns
-            int main() { ^ns::Foo::bar(); }
-          )cpp",
-          "text[Declared in]code[global namespace]\n"
-          "codeblock(cpp) [\n"
-          "namespace ns {}\n"
-          "]",
-      },
-      {
-          R"cpp(// Anonymous namespace
-            namespace ns {
-              namespace {
-                int foo;
-              } // anonymous namespace
-            } // namespace ns
-            int main() { ns::f^oo++; }
-          )cpp",
-          "text[Declared in]code[ns::(anonymous)]\n"
-          "codeblock(cpp) [\n"
-          "int foo\n"
-          "]",
-      },
-      {
-          R"cpp(// Macro
-            #define MACRO 0
-            #define MACRO 1
-            int main() { return ^MACRO; }
-            #define MACRO 2
-            #undef macro
-          )cpp",
-          "codeblock(cpp) [\n"
-          "#define MACRO 1\n"
-          "]",
-      },
-      {
-          R"cpp(// Macro
-            #define MACRO 0
-            #define MACRO2 ^MACRO
-          )cpp",
-          "codeblock(cpp) [\n"
-          "#define MACRO 0\n"
-          "]",
-      },
-      {
-          R"cpp(// Macro
-            #define MACRO {\
-              return 0;\
-            }
-            int main() ^MACRO
-          )cpp",
-          R"cpp(codeblock(cpp) [
-#define MACRO                                                                  \
-  { return 0; }
-])cpp",
-      },
-      {
-          R"cpp(// Forward class declaration
-            class Foo;
-            class Foo {};
-            F^oo* foo();
-          )cpp",
-          "text[Declared in]code[global namespace]\n"
-          "codeblock(cpp) [\n"
-          "class Foo {}\n"
-          "]\n"
-          "text[Forward class declaration]",
-      },
-      {
-          R"cpp(// Function declaration
-            void foo();
-            void g() { f^oo(); }
-            void foo() {}
-          )cpp",
-          "text[Declared in]code[global namespace]\n"
-          "codeblock(cpp) [\n"
-          "void foo()\n"
-          "]\n"
-          "text[Function declaration]",
-      },
-      {
-          R"cpp(// Enum declaration
-            enum Hello {
-              ONE, TWO, THREE,
-            };
-            void foo() {
-              Hel^lo hello = ONE;
-            }
-          )cpp",
-          "text[Declared in]code[global namespace]\n"
-          "codeblock(cpp) [\n"
-          "enum Hello {}\n"
-          "]\n"
-          "text[Enum declaration]",
-      },
-      {
-          R"cpp(// Enumerator
-            enum Hello {
-              ONE, TWO, THREE,
-            };
-            void foo() {
-              Hello hello = O^NE;
-            }
-          )cpp",
-          "text[Declared in]code[Hello]\n"
-          "codeblock(cpp) [\n"
-          "ONE\n"
-          "]",
-      },
-      {
-          R"cpp(// Enumerator in anonymous enum
-            enum {
-              ONE, TWO, THREE,
-            };
-            void foo() {
-              int hello = O^NE;
-            }
-          )cpp",
-          "text[Declared in]code[global namespace]\n"
-          "codeblock(cpp) [\n"
-          "ONE\n"
-          "]",
-      },
-      {
-          R"cpp(// Global variable
-            static int hey = 10;
-            void foo() {
-              he^y++;
-            }
-          )cpp",
-          "text[Declared in]code[global namespace]\n"
-          "codeblock(cpp) [\n"
-          "static int hey = 10\n"
-          "]\n"
-          "text[Global variable]",
-      },
-      {
-          R"cpp(// Global variable in namespace
-            namespace ns1 {
-              static int hey = 10;
-            }
-            void foo() {
-              ns1::he^y++;
-            }
-          )cpp",
-          "text[Declared in]code[ns1]\n"
-          "codeblock(cpp) [\n"
-          "static int hey = 10\n"
-          "]",
-      },
-      {
-          R"cpp(// Field in anonymous struct
-            static struct {
-              int hello;
-            } s;
-            void foo() {
-              s.he^llo++;
-            }
-          )cpp",
-          "text[Declared in]code[(anonymous struct)]\n"
-          "codeblock(cpp) [\n"
-          "int hello\n"
-          "]",
-      },
-      {
-          R"cpp(// Templated function
-            template <typename T>
-            T foo() {
-              return 17;
-            }
-            void g() { auto x = f^oo<int>(); }
-          )cpp",
-          "text[Declared in]code[global namespace]\n"
-          "codeblock(cpp) [\n"
-          "template <typename T> T foo()\n"
-          "]\n"
-          "text[Templated function]",
-      },
-      {
-          R"cpp(// Anonymous union
-            struct outer {
-              union {
-                int abc, def;
-              } v;
-            };
-            void g() { struct outer o; o.v.d^ef++; }
-          )cpp",
-          "text[Declared in]code[outer::(anonymous union)]\n"
-          "codeblock(cpp) [\n"
-          "int def\n"
-          "]",
-      },
-      {
-          R"cpp(// documentation from index
-            int nextSymbolIsAForwardDeclFromIndexWithNoLocalDocs;
-            void indexSymbol();
-            void g() { ind^exSymbol(); }
-          )cpp",
-          "text[Declared in]code[global namespace]\n"
-          "codeblock(cpp) [\n"
-          "void indexSymbol()\n"
-          "]\n"
-          "text[comment from index]",
-      },
-      {
-          R"cpp(// Nothing
-            void foo() {
-              ^
-            }
-          )cpp",
-          "",
-      },
-      {
-          R"cpp(// Simple initialization with auto
-            void foo() {
-              ^auto i = 1;
-            }
-          )cpp",
-          "codeblock(cpp) [\n"
-          "int\n"
-          "]",
-      },
-      {
-          R"cpp(// Simple initialization with const auto
-            void foo() {
-              const ^auto i = 1;
-            }
-          )cpp",
-          "codeblock(cpp) [\n"
-          "int\n"
-          "]",
-      },
-      {
-          R"cpp(// Simple initialization with const auto&
-            void foo() {
-              const ^auto& i = 1;
-            }
-          )cpp",
-          "codeblock(cpp) [\n"
-          "int\n"
-          "]",
-      },
-      {
-          R"cpp(// Simple initialization with auto&
-            void foo() {
-              ^auto& i = 1;
-            }
-          )cpp",
-          "codeblock(cpp) [\n"
-          "int\n"
-          "]",
-      },
-      {
-          R"cpp(// Simple initialization with auto*
-            void foo() {
-              int a = 1;
-              ^auto* i = &a;
-            }
-          )cpp",
-          "codeblock(cpp) [\n"
-          "int\n"
-          "]",
-      },
-      {
-          R"cpp(// Auto with initializer list.
-            namespace std
-            {
-              template<class _E>
-              class initializer_list {};
-            }
-            void foo() {
-              ^auto i = {1,2};
-            }
-          )cpp",
-          "codeblock(cpp) [\n"
-          "class std::initializer_list<int>\n"
-          "]",
-      },
-      {
-          R"cpp(// User defined conversion to auto
-            struct Bar {
-              operator ^auto() const { return 10; }
-            };
-          )cpp",
-          "codeblock(cpp) [\n"
-          "int\n"
-          "]",
-      },
-      {
-          R"cpp(// Simple initialization with decltype(auto)
-            void foo() {
-              ^decltype(auto) i = 1;
-            }
-          )cpp",
-          "codeblock(cpp) [\n"
-          "int\n"
-          "]",
-      },
-      {
-          R"cpp(// Simple initialization with const decltype(auto)
-            void foo() {
-              const int j = 0;
-              ^decltype(auto) i = j;
-            }
-          )cpp",
-          "codeblock(cpp) [\n"
-          "const int\n"
-          "]",
-      },
-      {
-          R"cpp(// Simple initialization with const& decltype(auto)
-            void foo() {
-              int k = 0;
-              const int& j = k;
-              ^decltype(auto) i = j;
-            }
-          )cpp",
-          "codeblock(cpp) [\n"
-          "const int &\n"
-          "]",
-      },
-      {
-          R"cpp(// Simple initialization with & decltype(auto)
-            void foo() {
-              int k = 0;
-              int& j = k;
-              ^decltype(auto) i = j;
-            }
-          )cpp",
-          "codeblock(cpp) [\n"
-          "int &\n"
-          "]",
-      },
-      {
-          R"cpp(// decltype with initializer list: nothing
-            namespace std
-            {
-              template<class _E>
-              class initializer_list {};
-            }
-            void foo() {
-              ^decltype(auto) i = {1,2};
-            }
-          )cpp",
-          "",
-      },
-      {
-          R"cpp(// simple trailing return type
-            ^auto main() -> int {
-              return 0;
-            }
-          )cpp",
-          "codeblock(cpp) [\n"
-          "int\n"
-          "]",
-      },
-      {
-          R"cpp(// auto function return with trailing type
-            struct Bar {};
-            ^auto test() -> decltype(Bar()) {
-              return Bar();
-            }
-          )cpp",
-          "codeblock(cpp) [\n"
-          "struct Bar\n"
-          "]",
-      },
-      {
-          R"cpp(// trailing return type
-            struct Bar {};
-            auto test() -> ^decltype(Bar()) {
-              return Bar();
-            }
-          )cpp",
-          "codeblock(cpp) [\n"
-          "struct Bar\n"
-          "]",
-      },
-      {
-          R"cpp(// auto in function return
-            struct Bar {};
-            ^auto test() {
-              return Bar();
-            }
-          )cpp",
-          "codeblock(cpp) [\n"
-          "struct Bar\n"
-          "]",
-      },
-      {
-          R"cpp(// auto& in function return
-            struct Bar {};
-            ^auto& test() {
-              return Bar();
-            }
-          )cpp",
-          "codeblock(cpp) [\n"
-          "struct Bar\n"
-          "]",
-      },
-      {
-          R"cpp(// auto* in function return
-            struct Bar {};
-            ^auto* test() {
-              Bar* bar;
-              return bar;
-            }
-          )cpp",
-          "codeblock(cpp) [\n"
-          "struct Bar\n"
-          "]",
-      },
-      {
-          R"cpp(// const auto& in function return
-            struct Bar {};
-            const ^auto& test() {
-              return Bar();
-            }
-          )cpp",
-          "codeblock(cpp) [\n"
-          "struct Bar\n"
-          "]",
-      },
-      {
-          R"cpp(// decltype(auto) in function return
-            struct Bar {};
-            ^decltype(auto) test() {
-              return Bar();
-            }
-          )cpp",
-          "codeblock(cpp) [\n"
-          "struct Bar\n"
-          "]",
-      },
-      {
-          R"cpp(// decltype(auto) reference in function return
-            struct Bar {};
-            ^decltype(auto) test() {
-              int a;
-              return (a);
-            }
-          )cpp",
-          "codeblock(cpp) [\n"
-          "int &\n"
-          "]",
-      },
-      {
-          R"cpp(// decltype lvalue reference
-            void foo() {
-              int I = 0;
-              ^decltype(I) J = I;
-            }
-          )cpp",
-          "codeblock(cpp) [\n"
-          "int\n"
-          "]",
-      },
-      {
-          R"cpp(// decltype lvalue reference
-            void foo() {
-              int I= 0;
-              int &K = I;
-              ^decltype(K) J = I;
-            }
-          )cpp",
-          "codeblock(cpp) [\n"
-          "int &\n"
-          "]",
-      },
-      {
-          R"cpp(// decltype lvalue reference parenthesis
-            void foo() {
-              int I = 0;
-              ^decltype((I)) J = I;
-            }
-          )cpp",
-          "codeblock(cpp) [\n"
-          "int &\n"
-          "]",
-      },
-      {
-          R"cpp(// decltype rvalue reference
-            void foo() {
-              int I = 0;
-              ^decltype(static_cast<int&&>(I)) J = static_cast<int&&>(I);
-            }
-          )cpp",
-          "codeblock(cpp) [\n"
-          "int &&\n"
-          "]",
-      },
-      {
-          R"cpp(// decltype rvalue reference function call
-            int && bar();
-            void foo() {
-              int I = 0;
-              ^decltype(bar()) J = bar();
-            }
-          )cpp",
-          "codeblock(cpp) [\n"
-          "int &&\n"
-          "]",
-      },
-      {
-          R"cpp(// decltype of function with trailing return type.
-            struct Bar {};
-            auto test() -> decltype(Bar()) {
-              return Bar();
-            }
-            void foo() {
-              ^decltype(test()) i = test();
-            }
-          )cpp",
-          "codeblock(cpp) [\n"
-          "struct Bar\n"
-          "]",
-      },
-      {
-          R"cpp(// decltype of var with decltype.
-            void foo() {
-              int I = 0;
-              decltype(I) J = I;
-              ^decltype(J) K = J;
-            }
-          )cpp",
-          "codeblock(cpp) [\n"
-          "int\n"
-          "]",
-      },
-      {
-          R"cpp(// structured binding. Not supported yet
-            struct Bar {};
-            void foo() {
-              Bar a[2];
-              ^auto [x,y] = a;
-            }
-          )cpp",
-          "",
-      },
-      {
-          R"cpp(// Template auto parameter. Nothing (Not useful).
-            template<^auto T>
-            void func() {
-            }
-            void foo() {
-               func<1>();
-            }
-          )cpp",
-          "",
-      },
-      {
-          R"cpp(// More compilcated structured types.
-            int bar();
-            ^auto (*foo)() = bar;
-          )cpp",
-          "codeblock(cpp) [\n"
-          "int\n"
-          "]",
-      },
-      {
-          R"cpp(// Should not crash when evaluating the initializer.
-            struct Test {};
-            void test() { Test && te^st = {}; }
-          )cpp",
-          "text[Declared in]code[test]\n"
-          "codeblock(cpp) [\n"
-          "struct Test &&test = {}\n"
-          "]",
-      },
-  };
-
-  // Create a tiny index, so tests above can verify documentation is fetched.
-  Symbol IndexSym = func("indexSymbol");
-  IndexSym.Documentation = "comment from index";
-  SymbolSlab::Builder Symbols;
-  Symbols.insert(IndexSym);
-  auto Index =
-      MemIndex::build(std::move(Symbols).build(), RefSlab(), RelationSlab());
-
-  for (const OneTest &Test : Tests) {
-    Annotations T(Test.Input);
-    TestTU TU = TestTU::withCode(T.code());
-    TU.ExtraArgs.push_back("-std=c++17");
-    auto AST = TU.build();
-    if (auto H =
-            getHover(AST, T.point(), format::getLLVMStyle(), Index.get())) {
-      EXPECT_NE("", Test.ExpectedHover) << Test.Input;
-      EXPECT_EQ(H->present().renderForTests(), Test.ExpectedHover.str())
-          << Test.Input;
-    } else
-      EXPECT_EQ("", Test.ExpectedHover.str()) << Test.Input;
-  }
-}
-
 TEST(GoToInclude, All) {
   MockFSProvider FS;
   IgnoreDiagnostics DiagConsumer;
@@ -2231,30 +939,6 @@
   }
 }
 
-TEST(GetDeducedType, KwAutoExpansion) {
-  struct Test {
-    StringRef AnnotatedCode;
-    const char *DeducedType;
-  } Tests[] = {
-      {"^auto i = 0;", "int"},
-      {"^auto f(){ return 1;};", "int"},
-  };
-  for (Test T : Tests) {
-    Annotations File(T.AnnotatedCode);
-    auto AST = TestTU::withCode(File.code()).build();
-    ASSERT_TRUE(AST.getDiagnostics().empty())
-        << AST.getDiagnostics().begin()->Message;
-    SourceManagerForFile SM("foo.cpp", File.code());
-
-    for (Position Pos : File.points()) {
-      auto Location = sourceLocationInMainFile(SM.get(), Pos);
-      ASSERT_TRUE(!!Location) << llvm::toString(Location.takeError());
-      auto DeducedType = getDeducedType(AST, *Location);
-      EXPECT_EQ(DeducedType->getAsString(), T.DeducedType);
-    }
-  }
-}
-
 TEST(GetNonLocalDeclRefs, All) {
   struct Case {
     llvm::StringRef AnnotatedCode;