[clangd][WIP] Add doxygen parsing for Hover

clang-tools-extra/clangd/CMakeLists.txt

add_clang_library(clangDaemon
   Quality.cpp
   ParsedAST.cpp
   Preamble.cpp
   RIFF.cpp
   Selection.cpp
   SemanticHighlighting.cpp
   SemanticSelection.cpp
   SourceCode.cpp
+  SymbolDocumentation.cpp
   QueryDriverDatabase.cpp
   TidyProvider.cpp
   TUScheduler.cpp
   URI.cpp
   XRefs.cpp
   ${CMAKE_CURRENT_BINARY_DIR}/CompletionModel.cpp
 
   index/Background.cpp

clang-tools-extra/clangd/CodeComplete.cpp

if (!Completion.Documentation) {
           parseDocumentation(Doc, *Completion.Documentation);
         }
       };
       if (C.IndexResult) {
         SetDoc(C.IndexResult->Documentation);
       } else if (C.SemaResult) {
         const auto DocComment = getDocComment(*ASTCtx, *C.SemaResult,
                                               /*CommentsFromHeaders=*/false);
-        SetDoc(formatDocumentation(*SemaCCS, DocComment));
+        SetDoc(formatDocumentation(*SemaCCS, DocComment.CommentText));
       }
     }
     if (Completion.Deprecated) {
       if (C.SemaResult)
         Completion.Deprecated &=
             C.SemaResult->Availability == CXAvailability_Deprecated;
       if (C.IndexResult)
         Completion.Deprecated &=
for (unsigned I = 0; I < NumCandidates; ++I) {
       const auto *CCS = Candidate.CreateSignatureString(
           CurrentArg, S, *Allocator, CCTUInfo,
           /*IncludeBriefComments=*/true, Braced);
       assert(CCS && "Expected the CodeCompletionString to be non-null");
       ScoredSignatures.push_back(processOverloadCandidate(
           Candidate, *CCS,
           Candidate.getFunction()
               ? getDeclComment(S.getASTContext(), *Candidate.getFunction())
-              : ""));
+              : SymbolDocumentation{}));
     }
 
     // Sema does not load the docs from the preamble, so we need to fetch extra
     // docs from the index instead.
     llvm::DenseMap<SymbolID, std::string> FetchedDocs;
     if (Index) {
       LookupRequest IndexRequest;
       for (const auto &S : ScoredSignatures) {
for (const auto &Chunk : CCS) {
         Signature.label += Chunk.Text;
         break;
       }
     }
   }
 
   // FIXME(ioeric): consider moving CodeCompletionString logic here to
   // CompletionString.h.
-  ScoredSignature processOverloadCandidate(const OverloadCandidate &Candidate,
-                                           const CodeCompletionString &CCS,
-                                           llvm::StringRef DocComment) const {
+  ScoredSignature
+  processOverloadCandidate(const OverloadCandidate &Candidate,
+                           const SymbolDocumentation &DocComment) const {
     SignatureInformation Signature;
     SignatureQualitySignals Signal;
     const char *ReturnType = nullptr;
 
     markup::Document OverloadComment;
-    parseDocumentation(formatDocumentation(CCS, DocComment), OverloadComment);
+    parseDocumentation(formatDocumentation(CCS, DocComment.CommentText),
+                       OverloadComment);
     Signature.documentation = renderDoc(OverloadComment, DocumentationFormat);
     Signal.Kind = Candidate.getKind();
 
     for (const auto &Chunk : CCS) {
       switch (Chunk.Kind) {
       case CodeCompletionString::CK_ResultType:
         // A piece of text that describes the type of an entity or,
         // for functions and methods, the return type.

clang-tools-extra/clangd/CodeCompletionStrings.h

 //===--- CodeCompletionStrings.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
 //
 //===----------------------------------------------------------------------===//
 //
 // Functions for retrieving code completion information from
 // `CodeCompletionString`.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_CODECOMPLETIONSTRINGS_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANGD_CODECOMPLETIONSTRINGS_H
 
+#include "clang/AST/CommentVisitor.h"
 #include "clang/Sema/CodeCompleteConsumer.h"
 
+#include "SymbolDocumentation.h"
+
 namespace clang {
 class ASTContext;
 
 namespace clangd {
 
+/// TODO Update docs
 /// Gets a minimally formatted documentation comment of \p Result, with comment
 /// markers stripped. See clang::RawComment::getFormattedText() for the detailed
 /// explanation of how the comment text is transformed.
 /// Returns empty string when no comment is available.
 /// If \p CommentsFromHeaders parameter is set, only comments from the main
 /// file will be returned. It is used to workaround crashes when parsing
 /// comments in the stale headers, coming from completion preamble.
-std::string getDocComment(const ASTContext &Ctx,
+SymbolDocumentation getDocComment(const ASTContext &Ctx,
                                   const CodeCompletionResult &Result,
                                   bool CommentsFromHeaders);
 
-/// Similar to getDocComment, but returns the comment for a NamedDecl.
-std::string getDeclComment(const ASTContext &Ctx, const NamedDecl &D);
+SymbolDocumentation getDeclComment(const ASTContext &Ctx, const NamedDecl &D);
 
 /// Formats the signature for an item, as a display string and snippet.
 /// e.g. for const_reference std::vector<T>::at(size_type) const, this returns:
 ///   *Signature = "(size_type) const"
 ///   *Snippet = "(${1:size_type})"
 /// If set, RequiredQualifiers is the text that must be typed before the name.
 /// e.g "Base::" when calling a base class member function that's hidden.
 ///

clang-tools-extra/clangd/CodeCompletionStrings.cpp

bool looksLikeDocComment(llvm::StringRef CommentText) {
   //   =================
   //   -----------------
   //   *****************
   return CommentText.find_first_not_of("/*-= \t\r\n") != llvm::StringRef::npos;
 }
 
 } // namespace
 
-std::string getDocComment(const ASTContext &Ctx,
+SymbolDocumentation getDocComment(const ASTContext &Ctx,
                                   const CodeCompletionResult &Result,
                                   bool CommentsFromHeaders) {
+  // FIXME: CommentsFromHeaders seems to be unused? Is this a bug?
+
   // FIXME: clang's completion also returns documentation for RK_Pattern if they
   // contain a pattern for ObjC properties. Unfortunately, there is no API to
   // get this declaration, so we don't show documentation in that case.
   if (Result.Kind != CodeCompletionResult::RK_Declaration)
-    return "";
+    return {};
   return Result.getDeclaration() ? getDeclComment(Ctx, *Result.getDeclaration())
-                                 : "";
+                                 : SymbolDocumentation{};
 }
 
-std::string getDeclComment(const ASTContext &Ctx, const NamedDecl &Decl) {
+SymbolDocumentation getDeclComment(const ASTContext &Ctx,
+                                   const NamedDecl &Decl) {
   if (isa<NamespaceDecl>(Decl)) {
     // Namespaces often have too many redecls for any particular redecl comment
     // to be useful. Moreover, we often confuse file headers or generated
     // comments with namespace comments. Therefore we choose to just ignore
     // the comments for namespaces.
-    return "";
+    return {};
   }
   const RawComment *RC = getCompletionComment(Ctx, &Decl);
   if (!RC)
-    return "";
+    return {};
   // Sanity check that the comment does not come from the PCH. We choose to not
   // write them into PCH, because they are racy and slow to load.
   assert(!Ctx.getSourceManager().isLoadedSourceLocation(RC->getBeginLoc()));
-  std::string Doc =
-      RC->getFormattedText(Ctx.getSourceManager(), Ctx.getDiagnostics());
-  if (!looksLikeDocComment(Doc))
-    return "";
+
+  // TODO Figure out where to get the Preprocessor from (3rd arg)...?
+  SymbolDocumentation Doc(*RC, Ctx, nullptr, &Decl);
+
+  if (!looksLikeDocComment(Doc.CommentText))
+    return {};
+
+  // TODO where should be put this check now?
   // Clang requires source to be UTF-8, but doesn't enforce this in comments.
-  if (!llvm::json::isUTF8(Doc))
-    Doc = llvm::json::fixUTF8(Doc);
+  //
+  // if (!llvm::json::isUTF8(Doc))
+  //   Doc = llvm::json::fixUTF8(Doc);
+
   return Doc;
 }
 
 void getSignature(const CodeCompletionString &CCS, std::string *Signature,
                   std::string *Snippet, std::string *RequiredQualifiers,
                   bool CompletingPattern) {
   // Placeholder with this index will be ${0:…} to mark final cursor position.
   // Usually we do not add $0, so the cursor is placed at end of completed text.

clang-tools-extra/clangd/Hover.h

 //===--- Hover.h - Information about code at the cursor location -*- 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_HOVER_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANGD_HOVER_H
 
+#include "CodeCompletionStrings.h"
 #include "ParsedAST.h"
 #include "Protocol.h"
 #include "support/Markup.h"
 #include "clang/Index/IndexSymbol.h"
 
 namespace clang {
 namespace clangd {
 
struct HoverInfo {
   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;
   index::SymbolKind Kind = index::SymbolKind::Unknown;
-  std::string Documentation;
+  SymbolDocumentation Documentation;
   /// Source code containing the definition of the symbol.
   std::string Definition;
   const char *DefinitionLanguage = "cpp";
   /// Access specifier for declarations inside class/struct/unions, empty for
   /// others.
   std::string AccessSpecifier;
   /// Printable variable type.
   /// Set only for variables.

clang-tools-extra/clangd/Hover.cpp

if (!SymbolCollector::shouldCollectSymbol(ND, ND.getASTContext(),
                                             /*IsMainFileOnly=*/false))
     return;
   auto ID = getSymbolID(&ND);
   if (!ID)
     return;
   LookupRequest Req;
   Req.IDs.insert(ID);
   Index->lookup(Req, [&](const Symbol &S) {
-    Hover.Documentation = std::string(S.Documentation);
+    Hover.Documentation.CommentText = std::string(S.Documentation);
   });
 }
 
 // Default argument might exist but be unavailable, in the case of unparsed
 // arguments for example. This function returns the default argument if it is
 // available.
 const Expr *getDefaultArg(const ParmVarDecl *PVD) {
   // Default argument can be unparsed or uninstantiated. For the former we
markup::Document HoverInfo::present() const {
   markup::Paragraph &Header = Output.addHeading(3);
   if (Kind != index::SymbolKind::Unknown)
     Header.appendText(index::getSymbolKindString(Kind)).appendSpace();
   assert(!Name.empty() && "hover triggered on a nameless symbol");
   Header.appendCode(Name);
 
   // Put a linebreak after header to increase readability.
   Output.addRuler();
+
+  if (!Documentation.Brief.empty())
+    Output.addParagraph().appendText(Documentation.Brief);
+
   // Print Types on their own lines to reduce chances of getting line-wrapped by
   // editor, as they might be long.
   if (ReturnType) {
     // For functions we display signature in a list form, e.g.:
     // → `x`
     // Parameters:
     // - `bool param1`
     // - `int param2 = 5`
-    Output.addParagraph().appendText("→ ").appendCode(
-        llvm::to_string(*ReturnType));
+    Output.addParagraph()
+        .appendText("→ ")
+        .appendCode(llvm::to_string(*ReturnType))
+        .appendText(": ")
+        .appendText(Documentation.Returns);
   }
-
   if (Parameters && !Parameters->empty()) {
     Output.addParagraph().appendText("Parameters: ");
     markup::BulletList &L = Output.addBulletList();
-    for (const auto &Param : *Parameters)
-      L.addItem().addParagraph().appendCode(llvm::to_string(Param));
+    unsigned ParamIndex = 0;
+    for (const auto &Param : *Parameters) {
+      auto &Paragraph = L.addItem().addParagraph();
+      Paragraph.appendCode(llvm::to_string(Param));
+
+      const auto Parameter =
+          Documentation.MatchingParameterDocs.find(ParamIndex);
+      if (Parameter != Documentation.MatchingParameterDocs.end()) {
+        Paragraph.appendText(": ").appendText(Parameter->second.Description);
+      }
+
+      ++ParamIndex;
+    }
+
+    for (const auto &ParamDoc : Documentation.UnmatchedParameterDocs) {
+      L.addItem()
+          .addParagraph()
+          .appendCode(ParamDoc.Name)
+          .appendText(": ")
+          .appendText(ParamDoc.Description);
+    }
   }
 
   // Don't print Type after Parameters or ReturnType as this will just duplicate
   // the information
   if (Type && !ReturnType && !Parameters)
     Output.addParagraph().appendText("Type: ").appendCode(
         llvm::to_string(*Type));
 
if (CalleeArgInfo) {
     }
     if (CalleeArgInfo->Name)
       OS << "as " << CalleeArgInfo->Name;
     if (CallPassType->Converted && CalleeArgInfo->Type)
       OS << " (converted to " << CalleeArgInfo->Type->Type << ")";
     Output.addParagraph().appendText(OS.str());
   }
 
-  if (!Documentation.empty())
-    parseDocumentation(Documentation, Output);
+  if (!Documentation.Description.empty())
+    parseDocumentation(Documentation.Description, Output);
+
+  if (!Documentation.Throws.empty()) {
+    Output.addRuler();
+    Output.addParagraph().appendText("Throws: ");
+    markup::BulletList &L = Output.addBulletList();
+    for (const auto &Throws : Documentation.Throws)
+      L.addItem()
+          .addParagraph()
+          .appendCode(Throws.Exception)
+          .appendText(": ")
+          .appendText(Throws.Description);
+  }
+
+  if (!Documentation.Warnings.empty()) {
+    Output.addRuler();
+    Output.addParagraph()
+        .appendText("Warning")
+        .appendText(Documentation.Warnings.size() > 1 ? "s" : "")
+        .appendText(": ");
+    markup::BulletList &L = Output.addBulletList();
+    for (const auto &Warning : Documentation.Warnings)
+      L.addItem().addParagraph().appendText(Warning);
+  }
+
+  if (!Documentation.Notes.empty()) {
+    Output.addRuler();
+    Output.addParagraph()
+        .appendText("Note")
+        .appendText(Documentation.Notes.size() > 1 ? "s" : "")
+        .appendText(": ");
+    markup::BulletList &L = Output.addBulletList();
+    for (const auto &Note : Documentation.Notes)
+      L.addItem().addParagraph().appendText(Note);
+  }
 
   if (!Definition.empty()) {
     Output.addRuler();
     std::string ScopeComment;
     // Drop trailing "::".
     if (!LocalScope.empty()) {
       // Container name, e.g. class, method, function.
       // We might want to propagate some info about container type to print

clang-tools-extra/clangd/SymbolDocumentation.h

+//===--- SymbolDocumentation.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
+//
+//===----------------------------------------------------------------------===//
+//
+// Class to parse doxygen comments into a flat structure for consumption
+// in e.g. Hover and Code Completion
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_SYMBOLDOCUMENTATION_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_SYMBOLDOCUMENTATION_H
+
+#include "clang/AST/ASTContext.h"
+#include "clang/AST/Comment.h"
+#include "clang/AST/CommentVisitor.h"
+
+namespace clang {
+namespace clangd {
+
+struct ParameterDocumentation {
+  llvm::StringRef Name;
+  std::string Description;
+  llvm::Optional<comments::ParamCommandComment::PassDirection> PassDirection;
+};
+
+struct ExceptionDocumentation {
+  llvm::StringRef Exception;
+  std::string Description;
+};
+
+struct SymbolDocumentation {
+  SymbolDocumentation(const RawComment &RC, const ASTContext &Ctx,
+                      const Preprocessor *PP, const Decl *D);
+
+  void visitFullComment(const comments::FullComment *FC);
+  void visitParamCommandComment(const comments::ParamCommandComment *P);
+
+  SymbolDocumentation() = default;
+  SymbolDocumentation(const std::string &Doc) : CommentText(Doc) {}
+
+  bool empty() const { return CommentText.empty(); }
+
+  std::string Brief;
+
+  std::string Returns;
+
+  llvm::SmallVector<std::string> Notes;
+  llvm::SmallVector<std::string> Warnings;
+
+  /// \\param commands that match a parameter in the function declaration
+  std::map<unsigned, ParameterDocumentation> MatchingParameterDocs;
+
+  llvm::SmallVector<ParameterDocumentation> UnmatchedParameterDocs;
+
+  llvm::SmallVector<ExceptionDocumentation> Throws;
+
+  /// All the paragraphs we don't have any special handling for, e.g. \details
+  std::string Description;
+
+  /// The full text of the doxygen comment
+  std::string CommentText;
+};
+
+} // namespace clangd
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_SYMBOLDOCUMENTATION_H

clang-tools-extra/clangd/SymbolDocumentation.cpp

+//===--- SymbolDocumentation.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 "SymbolDocumentation.h"
+#include "clang/AST/TextNodeDumper.h"
+#include "llvm/Support/JSON.h"
+
+namespace clang {
+namespace clangd {
+
+/// Converts a BlockCommentToString,
+class BlockCommentToString
+    : public comments::ConstCommentVisitor<BlockCommentToString> {
+public:
+  BlockCommentToString(std::string &Out, const ASTContext &Ctx)
+      : Out(Out), Ctx(Ctx) {}
+
+  void visitParagraphComment(const comments::ParagraphComment *C) {
+    for (const auto *Child = C->child_begin(); Child != C->child_end();
+         ++Child) {
+      visit(*Child);
+    }
+    Out << "\n";
+  }
+
+  void visitBlockCommandComment(const comments::BlockCommandComment *B) {
+    Out << (B->getCommandMarker() == (comments::CommandMarkerKind::CMK_At)
+                ? '@'
+                : '\\')
+        << B->getCommandName(Ctx.getCommentCommandTraits());
+
+    visit(B->getParagraph());
+  }
+
+  void visitTextComment(const comments::TextComment *C) { Out << C->getText(); }
+
+  void visitInlineCommandComment(const comments::InlineCommandComment *C) {
+    const std::string SurroundWith = [C] {
+      switch (C->getRenderKind()) {
+      case comments::InlineCommandComment::RenderKind::RenderMonospaced:
+        return "`";
+      case comments::InlineCommandComment::RenderKind::RenderBold:
+        return "**";
+      case comments::InlineCommandComment::RenderKind::RenderEmphasized:
+        return "*";
+      default:
+        return "";
+      }
+    }();
+
+    Out << SurroundWith;
+    for (unsigned I = 0; I < C->getNumArgs(); ++I) {
+      Out << C->getArgText(I);
+    }
+    Out << SurroundWith;
+  }
+
+private:
+  llvm::raw_string_ostream Out;
+  const ASTContext &Ctx;
+};
+
+class CommentToSymbolDocumentation
+    : public comments::ConstCommentVisitor<CommentToSymbolDocumentation> {
+public:
+  CommentToSymbolDocumentation(const RawComment &RC, const ASTContext &Ctx,
+                               const Preprocessor *PP, const Decl *D,
+                               SymbolDocumentation &Doc)
+      : FullComment(RC.parse(Ctx, PP, D)), Output(Doc), Ctx(Ctx) {
+
+    Output.CommentText =
+        RC.getFormattedText(Ctx.getSourceManager(), Ctx.getDiagnostics());
+
+    for (auto *Block : FullComment->getBlocks()) {
+      visit(Block);
+    }
+  }
+
+  void visitBlockCommandComment(const comments::BlockCommandComment *B) {
+    const llvm::StringRef CommandName =
+        B->getCommandName(Ctx.getCommentCommandTraits());
+
+    // Visit B->getParagraph() for commands that we have special fields for,
+    // so that the command name won't be included in the string.
+    // Otherwise, we want to keep the command name, so visit B itself.
+    if (CommandName == "brief")
+      BlockCommentToString(Output.Brief, Ctx).visit(B->getParagraph());
+    else if (CommandName == "return")
+      BlockCommentToString(Output.Returns, Ctx).visit(B->getParagraph());
+    else if (CommandName == "throw" || CommandName == "throws" ||
+             CommandName == "exception") {
+      ExceptionDocumentation Doc;
+      // TODO Looks like comments::Parser does not parse this correctly,
+      // getNumArgs() is always zero and the exception argument is contained in
+      // the Paragraph instead.
+      if (B->getNumArgs() > 0)
+        Doc.Exception = B->getArgText(0);
+      BlockCommentToString(Doc.Description, Ctx).visit(B->getParagraph());
+      Output.Throws.emplace_back(std::move(Doc));
+    } else if (CommandName == "warning")
+      BlockCommentToString(Output.Warnings.emplace_back(), Ctx)
+          .visit(B->getParagraph());
+    else if (CommandName == "note")
+      BlockCommentToString(Output.Notes.emplace_back(), Ctx)
+          .visit(B->getParagraph());
+    else
+      BlockCommentToString(Output.Description, Ctx).visit(B);
+  }
+
+  void visitParagraphComment(const comments::ParagraphComment *P) {
+    BlockCommentToString(Output.Description, Ctx).visit(P);
+  }
+
+  void visitParamCommandComment(const comments::ParamCommandComment *P) {
+    ParameterDocumentation ParamDoc;
+    ParamDoc.Name = P->getParamNameAsWritten();
+    if (P->isDirectionExplicit())
+      ParamDoc.PassDirection = P->getDirection();
+
+    BlockCommentToString(ParamDoc.Description, Ctx).visit(P->getParagraph());
+
+    if (P->isParamIndexValid() && !P->isVarArgParam()) {
+      Output.MatchingParameterDocs.insert(
+          {P->getParamIndex(), std::move(ParamDoc)});
+    } else {
+      Output.UnmatchedParameterDocs.emplace_back(std::move(ParamDoc));
+    }
+  }
+
+private:
+  comments::FullComment *FullComment;
+  SymbolDocumentation &Output;
+  const ASTContext &Ctx;
+};
+
+SymbolDocumentation::SymbolDocumentation(const RawComment &RC,
+                                         const ASTContext &Ctx,
+                                         const Preprocessor *PP,
+                                         const Decl *D) {
+  CommentToSymbolDocumentation(RC, Ctx, PP, D, *this);
+}
+
+} // namespace clangd
+} // namespace clang

clang-tools-extra/clangd/index/SymbolCollector.cpp

const Symbol *SymbolCollector::addDeclaration(const NamedDecl &ND, SymbolID ID,
   // We use the primary template, as clang does during code completion.
   CodeCompletionResult SymbolCompletion(&getTemplateOrThis(ND), 0);
   const auto *CCS = SymbolCompletion.CreateCodeCompletionString(
       *ASTCtx, *PP, CodeCompletionContext::CCC_Symbol, *CompletionAllocator,
       *CompletionTUInfo,
       /*IncludeBriefComments*/ false);
   std::string Documentation =
       formatDocumentation(*CCS, getDocComment(Ctx, SymbolCompletion,
-                                              /*CommentsFromHeaders=*/true));
+                                              /*CommentsFromHeaders=*/true)
+                                    .CommentText);
   if (!(S.Flags & Symbol::IndexedForCodeCompletion)) {
     if (Opts.StoreAllDocumentation)
       S.Documentation = Documentation;
     Symbols.insert(S);
     return Symbols.find(S.ID);
   }
   S.Documentation = Documentation;
   std::string Signature;

llvm/utils/gn/secondary/clang-tools-extra/clangd/BUILD.gn

sources = [
     "Protocol.cpp",
     "Quality.cpp",
     "QueryDriverDatabase.cpp",
     "RIFF.cpp",
     "Selection.cpp",
     "SemanticHighlighting.cpp",
     "SemanticSelection.cpp",
     "SourceCode.cpp",
+    "SymbolDocumentation.cpp"
     "TUScheduler.cpp",
     "TidyProvider.cpp",
     "URI.cpp",
     "XRefs.cpp",
     "index/Background.cpp",
     "index/BackgroundIndexLoader.cpp",
     "index/BackgroundIndexStorage.cpp",
     "index/BackgroundQueue.cpp",