[clangd] Represent Hover result using FormattedString

[kadircet]

I think it makes more sense to expose semantical information in HoverInfo(like Name, Scope, Definition, etc), rather than formatted strings, and let this be serialized by the users of ClangdServer (as in D61497). This is what I'll perform with that patch anyway, since it aims to provide consumers of ClangdServer with sementical information. So it is up to you whether to change the layering or keep it as it is in this patch.

clang-tools-extra/clangd/ClangdLSPServer.cpp

853

Why not move R.contents.kind and R.range assignment out of the switch statement. and perform return after the switch. That way you can get rid of the llvm_unreachable(we would still get warnings for that switch-statement if someone adds a new MarkupKind but doesn't update that statement.

And hopefully we should fallback to PlainText if editor doesn't support any markupkinds known to us.

clang-tools-extra/clangd/Protocol.cpp

707

Maybe also vlog/elog the unknown kind? So that we can easily catch new additions to spec.

clang-tools-extra/clangd/Protocol.h

359

This is mentioned as PlainText in the specs

[ilya-biryukov]

In D61601#1492979, @kadircet wrote:

I think it makes more sense to expose semantical information in HoverInfo(like Name, Scope, Definition, etc), rather than formatted strings, and let this be serialized by the users of ClangdServer (as in D61497). This is what I'll perform with that patch anyway, since it aims to provide consumers of ClangdServer with sementical information. So it is up to you whether to change the layering or keep it as it is in this patch.

Having structured information instead of FormattedString looks good, this change mostly aims to add markdown support for resulting hover when the LSP clients have support for it.
I'm happy to restructure the HoverInfo to your liking if the current one seems problematic for any reason.

[ilya-biryukov]

clang-tools-extra/clangd/ClangdLSPServer.cpp

853

Done, we do want llvm_unreachable at the end, just in case a new MarkupKind gets added.

And hopefully we should fallback to PlainText if editor doesn't support any markupkinds known to us.

This is handled by the code parsing initialization options and it actually falls back to plaintext.

[ilya-biryukov]

• Move range and kind assignment out of the loop.
• Log error on failed deserialization of markup kind.
• s/Plaintext/PlainText

[kadircet]

I'm happy to restructure the HoverInfo to your liking if the current one seems problematic for any reason.

It will just cause more code move on my side, no problems apart from that

clang-tools-extra/clangd/Protocol.cpp

707

I was referring to the else case down below :D

[ilya-biryukov]

• Forgotten change

clang-tools-extra/clangd/Protocol.cpp

707

Thanks for catching that!
My mistake, I made the change but did not save the file.

[ilya-biryukov]

Planning to rebase this on top of D61497 and land afterwards in order to minimize merge conflicts.

[kadircet]

Ping, D61497 has landed

[ilya-biryukov]

• Rebase

[ilya-biryukov]

This is ready for review now

[kadircet]

LGTM, thanks!

clang-tools-extra/clangd/XRefs.cpp

998–999

Should this also be inlinecode, for consistency? I know it is not exactly code as the other two cases, but it might still be better to look similar in all cases

[ilya-biryukov]

• Create an inline code block for 'global namespace' too

[ilya-biryukov]

clang-tools-extra/clangd/XRefs.cpp

998–999

Yeah, wasn't sure. Turned into inline code, could tweak later if needed.

clang-tools-extra/clangd/ClangdLSPServer.h

private:
   /// The supported completion item kinds of the client.
   CompletionItemKindBitset SupportedCompletionItemKinds;
   /// Whether the client supports CodeAction response objects.
   bool SupportsCodeAction = false;
   /// From capabilities of textDocument/documentSymbol.
   bool SupportsHierarchicalDocumentSymbol = false;
   /// Whether the client supports showing file status.
   bool SupportFileStatus = false;
-  // Store of the current versions of the open documents.
+  /// Which kind of markup should we use in textDocument/hover responses.
+  MarkupKind HoverContentFormat = MarkupKind::Plaintext;
+
+  /// Store of the current versions of the open documents.
   DraftStore DraftMgr;
 
   // The CDB is created by the "initialize" LSP method.
   bool UseDirBasedCDB;                     // FIXME: make this a capability.
   llvm::Optional<Path> CompileCommandsDir; // FIXME: merge with capability?
   std::unique_ptr<GlobalCompilationDatabase> BaseCDB;
   // CDB is BaseCDB plus any comands overridden via LSP extensions.
   llvm::Optional<OverlayCDB> CDB;

clang-tools-extra/clangd/ClangdLSPServer.cpp

 //===--- ClangdLSPServer.cpp - LSP server ------------------------*- C++-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "ClangdLSPServer.h"
 #include "Diagnostics.h"
+#include "FormattedString.h"
 #include "Protocol.h"
 #include "SourceCode.h"
 #include "Trace.h"
 #include "URI.h"
 #include "clang/Tooling/Core/Replacement.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/ScopeExit.h"
 #include "llvm/Support/Errc.h"
void ClangdLSPServer::onInitialize(const InitializeParams &Params,
   if (Params.capabilities.WorkspaceSymbolKinds)
     SupportedSymbolKinds |= *Params.capabilities.WorkspaceSymbolKinds;
   if (Params.capabilities.CompletionItemKinds)
     SupportedCompletionItemKinds |= *Params.capabilities.CompletionItemKinds;
   SupportsCodeAction = Params.capabilities.CodeActionStructure;
   SupportsHierarchicalDocumentSymbol =
       Params.capabilities.HierarchicalDocumentSymbol;
   SupportFileStatus = Params.initializationOptions.FileStatus;
+  HoverContentFormat = Params.capabilities.HoverContentFormat;
   llvm::json::Object Result{
       {{"capabilities",
         llvm::json::Object{
             {"textDocumentSync", (int)TextDocumentSyncKind::Incremental},
             {"documentFormattingProvider", true},
             {"documentRangeFormattingProvider", true},
             {"documentOnTypeFormattingProvider",
              llvm::json::Object{
void ClangdLSPServer::onDocumentHighlight(
     Callback<std::vector<DocumentHighlight>> Reply) {
   Server->findDocumentHighlights(Params.textDocument.uri.file(),
                                  Params.position, std::move(Reply));
 }
 
 void ClangdLSPServer::onHover(const TextDocumentPositionParams &Params,
                               Callback<llvm::Optional<Hover>> Reply) {
   Server->findHover(Params.textDocument.uri.file(), Params.position,
-                    std::move(Reply));
+                    Bind(
+                        [this](decltype(Reply) Reply,
+                               llvm::Expected<llvm::Optional<HoverInfo>> H) {
+                          if (!H)
+                            return Reply(H.takeError());
+                          if (!*H)
+                            return Reply(llvm::None);
+
+                          Hover R;
+                          switch (HoverContentFormat) {
+                          case MarkupKind::Plaintext:
+                            R.contents.kind = MarkupKind::Plaintext;
+                            R.contents.value =
+                                (*H)->Content.renderAsPlainText();
+                            R.range = (*H)->Range;
+                            return Reply(std::move(R));
+                          case MarkupKind::Markdown:
+                            R.contents.kind = MarkupKind::Markdown;
+                            R.contents.value = (*H)->Content.renderAsMarkdown();
+                            R.range = (*H)->Range;
+                            return Reply(std::move(R));
+                          };
+                          llvm_unreachable("unhandled MarkupKind");
+                        },
+                        std::move(Reply)));
 }
 
 void ClangdLSPServer::onTypeHierarchy(
     const TypeHierarchyParams &Params,
     Callback<Optional<TypeHierarchyItem>> Reply) {
   Server->typeHierarchy(Params.textDocument.uri.file(), Params.position,
                         Params.resolve, Params.direction, std::move(Reply));
 }

clang-tools-extra/clangd/ClangdServer.h

 //===--- ClangdServer.h - Main clangd server code ----------------*- C++-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_CLANGDSERVER_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANGD_CLANGDSERVER_H
 
 #include "../clang-tidy/ClangTidyOptions.h"
 #include "Cancellation.h"
 #include "ClangdUnit.h"
 #include "CodeComplete.h"
 #include "FSProvider.h"
+#include "FormattedString.h"
 #include "Function.h"
 #include "GlobalCompilationDatabase.h"
 #include "Protocol.h"
 #include "TUScheduler.h"
 #include "XRefs.h"
 #include "index/Background.h"
 #include "index/FileIndex.h"
 #include "index/Index.h"
public:
   llvm::Optional<Path> switchSourceHeader(PathRef Path);
 
   /// Get document highlights for a given position.
   void findDocumentHighlights(PathRef File, Position Pos,
                               Callback<std::vector<DocumentHighlight>> CB);
 
   /// Get code hover for a given position.
   void findHover(PathRef File, Position Pos,
-                 Callback<llvm::Optional<Hover>> CB);
+                 Callback<llvm::Optional<HoverInfo>> CB);
 
   /// Get information about type hierarchy for a given position.
   void typeHierarchy(PathRef File, Position Pos, int Resolve,
                      TypeHierarchyDirection Direction,
                      Callback<llvm::Optional<TypeHierarchyItem>> CB);
 
   /// Retrieve the top symbols from the workspace matching a query.
   void workspaceSymbols(StringRef Query, int Limit,

clang-tools-extra/clangd/ClangdServer.cpp

 //===--- ClangdServer.cpp - Main clangd server code --------------*- C++-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===-------------------------------------------------------------------===//
 
 #include "ClangdServer.h"
 #include "ClangdUnit.h"
 #include "CodeComplete.h"
 #include "FindSymbols.h"
+#include "FormattedString.h"
 #include "Headers.h"
 #include "Protocol.h"
 #include "SourceCode.h"
 #include "TUScheduler.h"
 #include "Trace.h"
+#include "XRefs.h"
 #include "index/CanonicalIncludes.h"
 #include "index/FileIndex.h"
 #include "index/Merge.h"
 #include "refactor/Tweak.h"
 #include "clang/Format/Format.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/CompilerInvocation.h"
 #include "clang/Lex/Preprocessor.h"
if (!InpAST)
       return CB(InpAST.takeError());
     CB(clangd::findDocumentHighlights(InpAST->AST, Pos));
   };
 
   WorkScheduler.runWithAST("Highlights", File, Bind(Action, std::move(CB)));
 }
 
 void ClangdServer::findHover(PathRef File, Position Pos,
-                             Callback<llvm::Optional<Hover>> CB) {
-  auto Action = [Pos](Callback<llvm::Optional<Hover>> CB,
-                      llvm::Expected<InputsAndAST> InpAST) {
+                             Callback<llvm::Optional<HoverInfo>> CB) {
+  auto Action = [Pos](decltype(CB) CB, llvm::Expected<InputsAndAST> InpAST) {
     if (!InpAST)
       return CB(InpAST.takeError());
     CB(clangd::getHover(InpAST->AST, Pos));
   };
-
   WorkScheduler.runWithAST("Hover", File, Bind(Action, std::move(CB)));
 }
 
 void ClangdServer::typeHierarchy(PathRef File, Position Pos, int Resolve,
                                  TypeHierarchyDirection Direction,
                                  Callback<Optional<TypeHierarchyItem>> CB) {
   auto Action = [Pos, Resolve, Direction](decltype(CB) CB,
                                           Expected<InputsAndAST> InpAST) {

clang-tools-extra/clangd/FormattedString.h

public:
   void appendCodeBlock(std::string Code, std::string Language = "cpp");
   /// Append an inline block of C++ code. This translates to the ` block in
   /// markdown.
   /// EXPECTS: Code does not contain newlines.
   void appendInlineCode(std::string Code);
 
   std::string renderAsMarkdown() const;
   std::string renderAsPlainText() const;
+  std::string renderForTests() const;
 
 private:
   enum class ChunkKind {
     PlainText,       /// A plain text paragraph.
     CodeBlock,       /// A block of code.
     InlineCodeBlock, /// An inline block of code.
   };
   struct Chunk {

clang-tools-extra/clangd/FormattedString.cpp

 //===--- FormattedString.cpp --------------------------------*- C++-*------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #include "FormattedString.h"
 #include "clang/Basic/CharInfo.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/FormatVariadic.h"
 #include <cstddef>
 #include <string>
 
 namespace clang {
 namespace clangd {
 
 namespace {
 /// Escape a markdown text block. Ensures the punctuation will not introduce
case ChunkKind::CodeBlock:
       continue;
     }
     llvm_unreachable("unhanlded ChunkKind");
   }
   while (!R.empty() && isWhitespace(R.back()))
     R.pop_back();
   return R;
 }
+
+std::string FormattedString::renderForTests() const {
+  std::string R;
+  for (const auto &C : Chunks) {
+    switch (C.Kind) {
+    case ChunkKind::PlainText:
+      R += "text[" + C.Contents + "]";
+      break;
+    case ChunkKind::InlineCodeBlock:
+      R += "code[" + C.Contents + "]";
+      break;
+    case ChunkKind::CodeBlock:
+      if (!R.empty())
+        R += "\n";
+      R += llvm::formatv("codeblock({0}) [\n{1}\n]\n", C.Language, C.Contents);
+      break;
+    }
+  }
+  while (!R.empty() && isWhitespace(R.back()))
+    R.pop_back();
+  return R;
+}
 } // namespace clangd
 } // namespace clang

clang-tools-extra/clangd/Protocol.h

enum class OffsetEncoding {
   UTF8,
   // Length counts codepoints in unicode text. (Clangd extension).
   UTF32,
 };
 llvm::json::Value toJSON(const OffsetEncoding &);
 bool fromJSON(const llvm::json::Value &, OffsetEncoding &);
 llvm::raw_ostream &operator<<(llvm::raw_ostream &, OffsetEncoding);
 
+// Describes the content type that a client supports in various result literals
+// like `Hover`, `ParameterInfo` or `CompletionItem`.
+enum class MarkupKind {
+  Plaintext,
+  Markdown,
+};
+bool fromJSON(const llvm::json::Value &, MarkupKind &);
+llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, MarkupKind);
+
 // This struct doesn't mirror LSP!
 // The protocol defines deeply nested structures for client capabilities.
 // Instead of mapping them all, this just parses out the bits we care about.
 struct ClientCapabilities {
   /// The supported set of SymbolKinds for workspace/symbol.
   /// workspace.symbol.symbolKind.valueSet
   llvm::Optional<SymbolKindBitset> WorkspaceSymbolKinds;
 
struct ClientCapabilities {
   llvm::Optional<CompletionItemKindBitset> CompletionItemKinds;
 
   /// Client supports CodeAction return value for textDocument/codeAction.
   /// textDocument.codeAction.codeActionLiteralSupport.
   bool CodeActionStructure = false;
 
   /// Supported encodings for LSP character offsets. (clangd extension).
   llvm::Optional<std::vector<OffsetEncoding>> offsetEncoding;
+
+  /// The content format that should be used for Hover requests.
+  MarkupKind HoverContentFormat = MarkupKind::Plaintext;
 };
 bool fromJSON(const llvm::json::Value &, ClientCapabilities &);
 
 /// Clangd extension that's used in the 'compilationDatabaseChanges' in
 /// workspace/didChangeConfiguration to record updates to the in-memory
 /// compilation database.
 struct ClangdCompileCommand {
   std::string workingDirectory;

 };
 bool fromJSON(const llvm::json::Value &, CompletionContext &);
 
 struct CompletionParams : TextDocumentPositionParams {
   CompletionContext context;
 };
 bool fromJSON(const llvm::json::Value &, CompletionParams &);
 
-enum class MarkupKind {
-  PlainText,
-  Markdown,
-};
-
 struct MarkupContent {
-  MarkupKind kind = MarkupKind::PlainText;
+  MarkupKind kind = MarkupKind::Plaintext;
   std::string value;
 };
 llvm::json::Value toJSON(const MarkupContent &MC);
 
 struct Hover {
   /// The hover's content
   MarkupContent contents;
 

clang-tools-extra/clangd/Protocol.cpp

 
 #include "Protocol.h"
 #include "Logger.h"
 #include "URI.h"
 #include "clang/Basic/LLVM.h"
 #include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringSwitch.h"
+#include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/JSON.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace clang {
 namespace clangd {
if (auto *CodeAction = TextDocument->getObject("codeAction")) {
       if (CodeAction->getObject("codeActionLiteralSupport"))
         R.CodeActionStructure = true;
     }
     if (auto *DocumentSymbol = TextDocument->getObject("documentSymbol")) {
       if (auto HierarchicalSupport =
               DocumentSymbol->getBoolean("hierarchicalDocumentSymbolSupport"))
         R.HierarchicalDocumentSymbol = *HierarchicalSupport;
     }
+    if (auto *Hover = TextDocument->getObject("hover")) {
+      if (auto *ContentFormat = Hover->getArray("contentFormat")) {
+        for (const auto &Format : *ContentFormat) {
+          MarkupKind K = MarkupKind::Plaintext;
+          if (fromJSON(Format, K)) {
+            R.HoverContentFormat = K;
+            break;
+          }
+        }
+      }
+    }
   }
   if (auto *Workspace = O->getObject("workspace")) {
     if (auto *Symbol = Workspace->getObject("symbol")) {
       if (auto *SymbolKind = Symbol->getObject("symbolKind")) {
         if (auto *ValueSet = SymbolKind->get("valueSet")) {
           R.WorkspaceSymbolKinds.emplace();
           if (!fromJSON(*ValueSet, *R.WorkspaceSymbolKinds))
             return false;
if (!fromJSON(Params, static_cast<TextDocumentPositionParams &>(R)))
     return false;
   if (auto *Context = Params.getAsObject()->get("context"))
     return fromJSON(*Context, R.context);
   return true;
 }
 
 static llvm::StringRef toTextKind(MarkupKind Kind) {
   switch (Kind) {
-  case MarkupKind::PlainText:
+  case MarkupKind::Plaintext:
     return "plaintext";
   case MarkupKind::Markdown:
     return "markdown";
   }
   llvm_unreachable("Invalid MarkupKind");
 }
 
+bool fromJSON(const llvm::json::Value &V, MarkupKind &K) {
+  auto Str = V.getAsString();
+  if (!Str)
+    return false;
+  if (*Str == "plaintext")
+    K = MarkupKind::Plaintext;
+  else if (*Str == "markdown")
+    K = MarkupKind::Markdown;
+  else
+    return false;
+  return true;
+}
+
+llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, MarkupKind K) {
+  return OS << toTextKind(K);
+}
+
 llvm::json::Value toJSON(const MarkupContent &MC) {
   if (MC.value.empty())
     return nullptr;
 
   return llvm::json::Object{
       {"kind", toTextKind(MC.kind)},
       {"value", MC.value},
   };

clang-tools-extra/clangd/XRefs.h

 //===--- XRefs.h -------------------------------------------------*- C++-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Features that traverse references between symbols.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_XREFS_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANGD_XREFS_H
 
 #include "ClangdUnit.h"
+#include "FormattedString.h"
 #include "Protocol.h"
 #include "index/Index.h"
 #include "llvm/ADT/Optional.h"
 #include <vector>
 
 namespace clang {
 namespace clangd {
 

 /// Multiple locations may be returned, corresponding to distinct symbols.
 std::vector<LocatedSymbol> locateSymbolAt(ParsedAST &AST, Position Pos,
                                           const SymbolIndex *Index = nullptr);
 
 /// Returns highlights for all usages of a symbol at \p Pos.
 std::vector<DocumentHighlight> findDocumentHighlights(ParsedAST &AST,
                                                       Position Pos);
 
+struct HoverInfo {
+  FormattedString Content;
+  llvm::Optional<Range> Range;
+};
 /// Get the hover information when hovering at \p Pos.
-llvm::Optional<Hover> getHover(ParsedAST &AST, Position Pos);
+llvm::Optional<HoverInfo> getHover(ParsedAST &AST, Position Pos);
 
 /// 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,
                                      uint32_t Limit,
                                      const SymbolIndex *Index = nullptr);
 
 /// Get info about symbols at \p Pos.

clang-tools-extra/clangd/XRefs.cpp

 //===--- XRefs.cpp -----------------------------------------------*- C++-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #include "XRefs.h"
 #include "AST.h"
 #include "FindSymbols.h"
+#include "FormattedString.h"
 #include "Logger.h"
 #include "SourceCode.h"
 #include "URI.h"
 #include "index/Merge.h"
 #include "index/SymbolCollector.h"
 #include "index/SymbolLocation.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/RecursiveASTVisitor.h"
else if (const NamespaceDecl *ND = dyn_cast<NamespaceDecl>(DC))
     return namedDeclQualifiedName(ND, "namespace");
   else if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(DC))
     return namedDeclQualifiedName(FD, "function");
 
   return None;
 }
 
 /// Generate a \p Hover object given the declaration \p D.
-static Hover getHoverContents(const Decl *D) {
-  Hover H;
+static FormattedString getHoverContents(const Decl *D) {
+  FormattedString R;
   llvm::Optional<std::string> NamedScope = getScopeName(D);
 
   // Generate the "Declared in" section.
   if (NamedScope) {
     assert(!NamedScope->empty());
 
-    H.contents.value += "Declared in ";
-    H.contents.value += *NamedScope;
-    H.contents.value += "\n\n";
+    R.appendText("Declared in");
+    R.appendInlineCode(*NamedScope);
   }
 
   // We want to include the template in the Hover.
   if (TemplateDecl *TD = D->getDescribedTemplate())
     D = TD;
 
   std::string DeclText;
   llvm::raw_string_ostream OS(DeclText);
 
   PrintingPolicy Policy =
       printingPolicyForDecls(D->getASTContext().getPrintingPolicy());
-
   D->print(OS, Policy);
 
-  OS.flush();
-
-  H.contents.value += DeclText;
-  return H;
+  R.appendCodeBlock(OS.str());
+  return R;
 }
 
 /// Generate a \p Hover object given the type \p T.
-static Hover getHoverContents(QualType T, ASTContext &ASTCtx) {
-  Hover H;
-  std::string TypeText;
-  llvm::raw_string_ostream OS(TypeText);
+static FormattedString getHoverContents(QualType T, ASTContext &ASTCtx) {
+  std::string Code;
+  llvm::raw_string_ostream OS(Code);
   PrintingPolicy Policy = printingPolicyForDecls(ASTCtx.getPrintingPolicy());
   T.print(OS, Policy);
-  OS.flush();
-  H.contents.value += TypeText;
-  return H;
+
+  FormattedString R;
+  R.appendCodeBlock(OS.str());
+  return R;
 }
 
 /// Generate a \p Hover object given the macro \p MacroDecl.
-static Hover getHoverContents(MacroDecl Decl, ParsedAST &AST) {
+static FormattedString getHoverContents(MacroDecl Decl, ParsedAST &AST) {
   SourceManager &SM = AST.getASTContext().getSourceManager();
   std::string Definition = Decl.Name;
 
   // Try to get the full definition, not just the name
   SourceLocation StartLoc = Decl.Info->getDefinitionLoc();
   SourceLocation EndLoc = Decl.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)
         Definition = Buffer.substr(StartOffset, EndOffset - StartOffset).str();
     }
   }
 
-  Hover H;
-  H.contents.kind = MarkupKind::PlainText;
-  H.contents.value = "#define " + Definition;
-  return H;
+  FormattedString S;
+  S.appendCodeBlock("#define " + std::move(Definition));
+  return S;
 }
 
 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
llvm::Optional<QualType> getDeducedType(ParsedAST &AST,
   if (!(Tok.is(tok::kw_auto) || Tok.is(tok::kw_decltype)))
     return {};
 
   DeducedTypeVisitor V(SourceLocationBeg);
   V.TraverseAST(AST.getASTContext());
   return V.getDeducedType();
 }
 
-llvm::Optional<Hover> getHover(ParsedAST &AST, Position Pos) {
+llvm::Optional<HoverInfo> getHover(ParsedAST &AST, Position Pos) {
   const SourceManager &SourceMgr = AST.getASTContext().getSourceManager();
   SourceLocation SourceLocationBeg =
       getBeginningOfIdentifier(AST, Pos, SourceMgr.getMainFileID());
   // Identified symbols at a specific position.
   auto Symbols = getSymbolAtPosition(AST, SourceLocationBeg);
 
-  if (!Symbols.Macros.empty())
-    return getHoverContents(Symbols.Macros[0], AST);
+  if (!Symbols.Macros.empty()) {
+    HoverInfo H;
+    H.Content = getHoverContents(Symbols.Macros[0], AST);
+    return H;
+  }
 
-  if (!Symbols.Decls.empty())
-    return getHoverContents(Symbols.Decls[0]);
+  if (!Symbols.Decls.empty()) {
+    HoverInfo H;
+    H.Content = getHoverContents(Symbols.Decls[0]);
+    return H;
+  }
 
   auto DeducedType = getDeducedType(AST, SourceLocationBeg);
-  if (DeducedType && !DeducedType->isNull())
-    return getHoverContents(*DeducedType, AST.getASTContext());
+  if (DeducedType && !DeducedType->isNull()) {
+    HoverInfo H;
+    H.Content = getHoverContents(*DeducedType, AST.getASTContext());
+    return H;
+  }
 
   return None;
 }
 
 std::vector<Location> findReferences(ParsedAST &AST, Position Pos,
                                      uint32_t Limit, const SymbolIndex *Index) {
   if (!Limit)
     Limit = std::numeric_limits<uint32_t>::max();
getTypeHierarchy(ParsedAST &AST, Position Pos, int ResolveLevels,
   Optional<TypeHierarchyItem> Result =
       getTypeAncestors(*CXXRD, AST.getASTContext(), RPSet);
 
   // FIXME(nridge): Resolve type descendants if direction is Children or Both,
   // and ResolveLevels > 0.
 
   return Result;
 }
 
 } // namespace clangd
 } // namespace clang

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

OneTest Tests[] = {
       {
           R"cpp(// Local variable
             int main() {
               int bonjour;
               ^bonjour = 2;
               int test1 = bonjour;
             }
           )cpp",
-          "Declared in function main\n\nint bonjour",
+          "text[Declared in]code[function main]\n"
+          "codeblock(cpp) [\n"
+          "int bonjour\n"
+          "]",
       },
       {
           R"cpp(// Local variable in method
             struct s {
               void method() {
                 int bonjour;
                 ^bonjour = 2;
               }
             };
           )cpp",
-          "Declared in function s::method\n\nint bonjour",
+          "text[Declared in]code[function 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",
-          "Declared in namespace ns1\n\nstruct MyClass {}",
+          "text[Declared in]code[namespace ns1]\n"
+          "codeblock(cpp) [\n"
+          "struct MyClass {}\n"
+          "]",
       },
       {
           R"cpp(// Class
             namespace ns1 {
               class MyClass {};
             } // namespace ns1
             int main() {
               ns1::My^Class* Params;
             }
           )cpp",
-          "Declared in namespace ns1\n\nclass MyClass {}",
+          "text[Declared in]code[namespace 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",
-          "Declared in namespace ns1\n\nunion MyUnion {}",
+          "text[Declared in]code[namespace ns1]\n"
+          "codeblock(cpp) [\n"
+          "union MyUnion {}\n"
+          "]",
       },
       {
           R"cpp(// Function definition via pointer
             int foo(int) {}
             int main() {
               auto *X = &^foo;
             }
           )cpp",
-          "Declared in global namespace\n\nint foo(int)",
+          "text[Declared in]code[global namespace]\n"
+          "codeblock(cpp) [\n"
+          "int foo(int)\n"
+          "]",
       },
       {
           R"cpp(// Function declaration via call
             int foo(int);
             int main() {
               return ^foo(42);
             }
           )cpp",
-          "Declared in global namespace\n\nint foo(int)",
+          "text[Declared in]code[global namespace]\n"
+          "codeblock(cpp) [\n"
+          "int foo(int)\n"
+          "]",
       },
       {
           R"cpp(// Field
             struct Foo { int x; };
             int main() {
               Foo bar;
               bar.^x;
             }
           )cpp",
-          "Declared in struct Foo\n\nint x",
+          "text[Declared in]code[struct 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",
-          "Declared in struct Foo\n\nint x = 5",
+          "text[Declared in]code[struct Foo]\n"
+          "codeblock(cpp) [\n"
+          "int x = 5\n"
+          "]",
       },
       {
           R"cpp(// Static field
             struct Foo { static int x; };
             int main() {
               Foo::^x;
             }
           )cpp",
-          "Declared in struct Foo\n\nstatic int x",
+          "text[Declared in]code[struct Foo]\n"
+          "codeblock(cpp) [\n"
+          "static int x\n"
+          "]",
       },
       {
           R"cpp(// Field, member initializer
             struct Foo {
               int x;
               Foo() : ^x(0) {}
             };
           )cpp",
-          "Declared in struct Foo\n\nint x",
+          "text[Declared in]code[struct 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",
-          "Declared in struct Foo\n\nint x",
+          "text[Declared in]code[struct Foo]\n"
+          "codeblock(cpp) [\n"
+          "int x\n"
+          "]",
       },
       {
           R"cpp(// Field, field designator
             struct Foo { int x; };
             int main() {
               Foo bar = { .^x = 2 };
             }
           )cpp",
-          "Declared in struct Foo\n\nint x",
+          "text[Declared in]code[struct Foo]\n"
+          "codeblock(cpp) [\n"
+          "int x\n"
+          "]",
       },
       {
           R"cpp(// Method call
             struct Foo { int x(); };
             int main() {
               Foo bar;
               bar.^x();
             }
           )cpp",
-          "Declared in struct Foo\n\nint x()",
+          "text[Declared in]code[struct Foo]\n"
+          "codeblock(cpp) [\n"
+          "int x()\n"
+          "]",
       },
       {
           R"cpp(// Static method call
             struct Foo { static int x(); };
             int main() {
               Foo::^x();
             }
           )cpp",
-          "Declared in struct Foo\n\nstatic int x()",
+          "text[Declared in]code[struct Foo]\n"
+          "codeblock(cpp) [\n"
+          "static int x()\n"
+          "]",
       },
       {
           R"cpp(// Typedef
             typedef int Foo;
             int main() {
               ^Foo bar;
             }
           )cpp",
-          "Declared in global namespace\n\ntypedef int Foo",
+          "text[Declared in]code[global namespace]\n"
+          "codeblock(cpp) [\n"
+          "typedef int Foo\n"
+          "]",
       },
       {
           R"cpp(// Namespace
             namespace ns {
             struct Foo { static void bar(); }
             } // namespace ns
             int main() { ^ns::Foo::bar(); }
           )cpp",
-          "Declared in global namespace\n\nnamespace ns {\n}",
+          "text[Declared in]code[global namespace]\n"
+          "codeblock(cpp) [\n"
+          "namespace ns {\n}\n"
+          "]",
       },
       {
           R"cpp(// Anonymous namespace
             namespace ns {
               namespace {
                 int foo;
               } // anonymous namespace
             } // namespace ns
             int main() { ns::f^oo++; }
           )cpp",
-          "Declared in namespace ns::(anonymous)\n\nint foo",
+          "text[Declared in]code[namespace 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",
-          "#define MACRO 1",
+          "codeblock(cpp) [\n"
+          "#define MACRO 1\n"
+          "]",
       },
       {
           R"cpp(// Macro
             #define MACRO 0
             #define MACRO2 ^MACRO
           )cpp",
-          "#define MACRO 0",
+          "codeblock(cpp) [\n"
+          "#define MACRO 0\n"
+          "]",
       },
       {
           R"cpp(// Macro
             #define MACRO {\
               return 0;\
             }
             int main() ^MACRO
           )cpp",
-          R"cpp(#define MACRO {\
+          R"cpp(codeblock(cpp) [
+#define MACRO {\
               return 0;\
-            })cpp",
+            }
+])cpp",
       },
       {
           R"cpp(// Forward class declaration
             class Foo;
             class Foo {};
             F^oo* foo();
           )cpp",
-          "Declared in global namespace\n\nclass Foo {}",
+          "text[Declared in]code[global namespace]\n"
+          "codeblock(cpp) [\n"
+          "class Foo {}\n"
+          "]",
       },
       {
           R"cpp(// Function declaration
             void foo();
             void g() { f^oo(); }
             void foo() {}
           )cpp",
-          "Declared in global namespace\n\nvoid foo()",
+          "text[Declared in]code[global namespace]\n"
+          "codeblock(cpp) [\n"
+          "void foo()\n"
+          "]",
       },
       {
           R"cpp(// Enum declaration
             enum Hello {
               ONE, TWO, THREE,
             };
             void foo() {
               Hel^lo hello = ONE;
             }
           )cpp",
-          "Declared in global namespace\n\nenum Hello {\n}",
+          "text[Declared in]code[global namespace]\n"
+          "codeblock(cpp) [\n"
+          "enum Hello {\n}\n"
+          "]",
       },
       {
           R"cpp(// Enumerator
             enum Hello {
               ONE, TWO, THREE,
             };
             void foo() {
               Hello hello = O^NE;
             }
           )cpp",
-          "Declared in enum Hello\n\nONE",
+          "text[Declared in]code[enum Hello]\n"
+          "codeblock(cpp) [\n"
+          "ONE\n"
+          "]",
       },
       {
           R"cpp(// Enumerator in anonymous enum
             enum {
               ONE, TWO, THREE,
             };
             void foo() {
               int hello = O^NE;
             }
           )cpp",
-          "Declared in enum (anonymous)\n\nONE",
+          "text[Declared in]code[enum (anonymous)]\n"
+          "codeblock(cpp) [\n"
+          "ONE\n"
+          "]",
       },
       {
           R"cpp(// Global variable
             static int hey = 10;
             void foo() {
               he^y++;
             }
           )cpp",
-          "Declared in global namespace\n\nstatic int hey = 10",
+          "text[Declared in]code[global namespace]\n"
+          "codeblock(cpp) [\n"
+          "static int hey = 10\n"
+          "]",
       },
       {
           R"cpp(// Global variable in namespace
             namespace ns1 {
               static int hey = 10;
             }
             void foo() {
               ns1::he^y++;
             }
           )cpp",
-          "Declared in namespace ns1\n\nstatic int hey = 10",
+          "text[Declared in]code[namespace 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",
-          "Declared in struct (anonymous)\n\nint hello",
+          "text[Declared in]code[struct (anonymous)]\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",
-          "Declared in global namespace\n\ntemplate <typename T> T foo()",
+          "text[Declared in]code[global namespace]\n"
+          "codeblock(cpp) [\n"
+          "template <typename T> T foo()\n"
+          "]",
       },
       {
           R"cpp(// Anonymous union
             struct outer {
               union {
                 int abc, def;
               } v;
             };
             void g() { struct outer o; o.v.d^ef++; }
           )cpp",
-          "Declared in union outer::(anonymous)\n\nint def",
+          "text[Declared in]code[union outer::(anonymous)]\n"
+          "codeblock(cpp) [\n"
+          "int def\n"
+          "]",
       },
       {
           R"cpp(// Nothing
             void foo() {
               ^
             }
           )cpp",
           "",
       },
       {
           R"cpp(// Simple initialization with auto
             void foo() {
               ^auto i = 1;
             }
           )cpp",
-          "int",
+          "codeblock(cpp) [\n"
+          "int\n"
+          "]",
       },
       {
           R"cpp(// Simple initialization with const auto
             void foo() {
               const ^auto i = 1;
             }
           )cpp",
-          "int",
+          "codeblock(cpp) [\n"
+          "int\n"
+          "]",
       },
       {
           R"cpp(// Simple initialization with const auto&
             void foo() {
               const ^auto& i = 1;
             }
           )cpp",
-          "int",
+          "codeblock(cpp) [\n"
+          "int\n"
+          "]",
       },
       {
           R"cpp(// Simple initialization with auto&
             void foo() {
               ^auto& i = 1;
             }
           )cpp",
-          "int",
+          "codeblock(cpp) [\n"
+          "int\n"
+          "]",
       },
       {
           R"cpp(// Simple initialization with auto*
             void foo() {
               int a = 1;
               ^auto* i = &a;
             }
           )cpp",
-          "int",
+          "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",
-          "class std::initializer_list<int>",
+          "codeblock(cpp) [\n"
+          "class std::initializer_list<int>\n"
+          "]",
       },
       {
           R"cpp(// User defined conversion to auto
             struct Bar {
               operator ^auto() const { return 10; }
             };
           )cpp",
-          "int",
+          "codeblock(cpp) [\n"
+          "int\n"
+          "]",
       },
       {
           R"cpp(// Simple initialization with decltype(auto)
             void foo() {
               ^decltype(auto) i = 1;
             }
           )cpp",
-          "int",
+          "codeblock(cpp) [\n"
+          "int\n"
+          "]",
       },
       {
           R"cpp(// Simple initialization with const decltype(auto)
             void foo() {
               const int j = 0;
               ^decltype(auto) i = j;
             }
           )cpp",
-          "const int",
+          "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",
-          "const int &",
+          "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",
-          "int &",
+          "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",
-          "int",
+          "codeblock(cpp) [\n"
+          "int\n"
+          "]",
       },
       {
           R"cpp(// auto function return with trailing type
             struct Bar {};
             ^auto test() -> decltype(Bar()) {
               return Bar();
             }
           )cpp",
-          "struct Bar",
+          "codeblock(cpp) [\n"
+          "struct Bar\n"
+          "]",
       },
       {
           R"cpp(// trailing return type
             struct Bar {};
             auto test() -> ^decltype(Bar()) {
               return Bar();
             }
           )cpp",
-          "struct Bar",
+          "codeblock(cpp) [\n"
+          "struct Bar\n"
+          "]",
       },
       {
           R"cpp(// auto in function return
             struct Bar {};
             ^auto test() {
               return Bar();
             }
           )cpp",
-          "struct Bar",
+          "codeblock(cpp) [\n"
+          "struct Bar\n"
+          "]",
       },
       {
           R"cpp(// auto& in function return
             struct Bar {};
             ^auto& test() {
               return Bar();
             }
           )cpp",
-          "struct Bar",
+          "codeblock(cpp) [\n"
+          "struct Bar\n"
+          "]",
       },
       {
           R"cpp(// auto* in function return
             struct Bar {};
             ^auto* test() {
               Bar* bar;
               return bar;
             }
           )cpp",
-          "struct Bar",
+          "codeblock(cpp) [\n"
+          "struct Bar\n"
+          "]",
       },
       {
           R"cpp(// const auto& in function return
             struct Bar {};
             const ^auto& test() {
               return Bar();
             }
           )cpp",
-          "struct Bar",
+          "codeblock(cpp) [\n"
+          "struct Bar\n"
+          "]",
       },
       {
           R"cpp(// decltype(auto) in function return
             struct Bar {};
             ^decltype(auto) test() {
               return Bar();
             }
           )cpp",
-          "struct Bar",
+          "codeblock(cpp) [\n"
+          "struct Bar\n"
+          "]",
       },
       {
           R"cpp(// decltype(auto) reference in function return
             struct Bar {};
             ^decltype(auto) test() {
               int a;
               return (a);
             }
           )cpp",
-          "int &",
+          "codeblock(cpp) [\n"
+          "int &\n"
+          "]",
       },
       {
           R"cpp(// decltype lvalue reference
             void foo() {
               int I = 0;
               ^decltype(I) J = I;
             }
           )cpp",
-          "int",
+          "codeblock(cpp) [\n"
+          "int\n"
+          "]",
       },
       {
           R"cpp(// decltype lvalue reference
             void foo() {
               int I= 0;
               int &K = I;
               ^decltype(K) J = I;
             }
           )cpp",
-          "int &",
+          "codeblock(cpp) [\n"
+          "int &\n"
+          "]",
       },
       {
           R"cpp(// decltype lvalue reference parenthesis
             void foo() {
               int I = 0;
               ^decltype((I)) J = I;
             }
           )cpp",
-          "int &",
+          "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",
-          "int &&",
+          "codeblock(cpp) [\n"
+          "int &&\n"
+          "]",
       },
       {
           R"cpp(// decltype rvalue reference function call
             int && bar();
             void foo() {
               int I = 0;
               ^decltype(bar()) J = bar();
             }
           )cpp",
-          "int &&",
+          "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",
-          "struct Bar",
+          "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",
-          "int",
+          "codeblock(cpp) [\n"
+          "int\n"
+          "]",
       },
       {
           R"cpp(// structured binding. Not supported yet
             struct Bar {};
             void foo() {
               Bar a[2];
               ^auto [x,y] = a;
             }
])cpp",
           )cpp",
           "",
       },
       {
           R"cpp(// More compilcated structured types.
             int bar();
             ^auto (*foo)() = bar;
           )cpp",
-          "int",
+          "codeblock(cpp) [\n"
+          "int\n"
+          "]",
       },
   };
 
   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())) {
       EXPECT_NE("", Test.ExpectedHover) << Test.Input;
-      EXPECT_EQ(H->contents.value, Test.ExpectedHover.str()) << Test.Input;
+      EXPECT_EQ(H->Content.renderForTests(), Test.ExpectedHover.str())
+          << Test.Input;
     } else
       EXPECT_EQ("", Test.ExpectedHover.str()) << Test.Input;
   }
 }
 
 TEST(GoToInclude, All) {
   MockFSProvider FS;
   IgnoreDiagnostics DiagConsumer;