[clangd] Show used symbol on include hover.

clang-tools-extra/clangd/Hover.h

 #include "Protocol.h"
 #include "support/Markup.h"
 #include "clang/Index/IndexSymbol.h"
 #include <optional>
 
 namespace clang {
 namespace clangd {
 
+struct UsedSymbol {
+  std::string Name;
+  Position Pos;
+};
+inline bool operator<(const UsedSymbol &FstSym, const UsedSymbol &SndSym) {
+  return FstSym.Name < SndSym.Name;
+}
+
 /// Contains detailed information about a Symbol. Especially useful when
 /// generating hover responses. It can be rendered as a hover panel, or
 /// embedding clients can use the structured information to provide their own
 /// UI.
 struct HoverInfo {
   /// Contains pretty-printed type and desugared type
   struct PrintedType {
     PrintedType() = default;
struct HoverInfo {
   std::optional<uint64_t> Size;
   /// Contains the offset of fields within the enclosing class.
   std::optional<uint64_t> Offset;
   /// Contains the padding following a field within the enclosing class.
   std::optional<uint64_t> Padding;
   // Set when symbol is inside function call. Contains information extracted
   // from the callee definition about the argument this is passed as.
   std::optional<Param> CalleeArgInfo;
+
+  std::optional<std::set<UsedSymbol>> UsedSymbols;
   struct PassType {
     // How the variable is passed to callee.
     enum PassMode { Ref, ConstRef, Value };
     PassMode PassBy = Ref;
     // True if type conversion happened. This includes calls to implicit
     // constructor, as well as built-in type conversions. Casting to base class
     // is not considered conversion.
     bool Converted = false;

clang-tools-extra/clangd/Hover.cpp

 //===--- Hover.cpp - Information about code at the cursor location --------===//
 //
 // 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 "Hover.h"
 
 #include "AST.h"
 #include "CodeCompletionStrings.h"
 #include "Config.h"
 #include "FindTarget.h"
 #include "ParsedAST.h"
+#include "Protocol.h"
 #include "Selection.h"
 #include "SourceCode.h"
+#include "clang-include-cleaner/Analysis.h"
 #include "index/SymbolCollector.h"
 #include "support/Markup.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ASTDiagnostic.h"
 #include "clang/AST/ASTTypeTraits.h"
 #include "clang/AST/Attr.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclBase.h"
const NamedDecl *pickDeclToUse(llvm::ArrayRef<const NamedDecl *> Candidates) {
   auto BaseDecls = llvm::make_filter_range(
       Candidates, [](const NamedDecl *D) { return llvm::isa<UsingDecl>(D); });
   if (std::distance(BaseDecls.begin(), BaseDecls.end()) == 1)
     return *BaseDecls.begin();
 
   return Candidates.front();
 }
 
+// FIXME(bakalova): Remove after merging https://reviews.llvm.org/D143496
+std::vector<include_cleaner::SymbolReference>
+collectMacroReferences(ParsedAST &AST) {
+  const auto &SM = AST.getSourceManager();
+  //  FIXME: !!this is a hacky way to collect macro references.
+  std::vector<include_cleaner::SymbolReference> Macros;
+  auto &PP = AST.getPreprocessor();
+  for (const syntax::Token &Tok :
+       AST.getTokens().spelledTokens(SM.getMainFileID())) {
+    auto Macro = locateMacroAt(Tok, PP);
+    if (!Macro)
+      continue;
+    if (auto DefLoc = Macro->Info->getDefinitionLoc(); DefLoc.isValid())
+      Macros.push_back(
+          {Tok.location(),
+           include_cleaner::Macro{/*Name=*/PP.getIdentifierInfo(Tok.text(SM)),
+                                  DefLoc},
+           include_cleaner::RefType::Explicit});
+  }
+  return Macros;
+}
+
+void addUsedSymbols(const Inclusion &Inc, ParsedAST &AST,
+                    const std::vector<include_cleaner::SymbolReference> &Macros,
+                    HoverInfo &HI) {
+  const SourceManager &SM = AST.getSourceManager();
+  std::set<UsedSymbol> UsedSymbols;
+  include_cleaner::walkUsed(
+      AST.getLocalTopLevelDecls(), Macros, AST.getPragmaIncludes(), SM,
+      [&](const include_cleaner::SymbolReference &Ref,
+          llvm::ArrayRef<include_cleaner::Header> Providers) {
+        if (Ref.RT != include_cleaner::RefType::Explicit ||
+             !Ref.RefLocation.isFileID() ||
+            !SM.isWrittenInMainFile(SM.getSpellingLoc(Ref.RefLocation)) 
+           ) {
+          return;
+        }
+        std::string Name;
+        switch (Ref.Target.kind()) {
+        case include_cleaner::Symbol::Declaration:
+          Name = cast<NamedDecl>(Ref.Target.declaration())
+                     .getDeclName()
+                     .getAsString();
+          break;
+        case include_cleaner::Symbol::Macro:
+          Name = Ref.Target.macro().Name->getName();
+          break;
+        }
+
+        Position Pos = sourceLocToPosition(SM, Ref.RefLocation);
+        for (const include_cleaner::Header &H : Providers) {
+          switch (H.kind()) {
+          case include_cleaner::Header::Physical:
+            if (H.physical()->tryGetRealPathName() == Inc.Resolved) {
+              UsedSymbols.insert({Name, Pos});
+            }
+            break;
+          case include_cleaner::Header::Standard:
+            if (Inc.Written == H.standard().name()) {
+              UsedSymbols.insert({Name, Pos});
+            }
+            break;
+          case include_cleaner::Header::Verbatim:
+            if (Inc.Written == H.verbatim()) {
+              UsedSymbols.insert({Name, Pos});
+            }
+            break;
+          }
+        }
+      });
+
+  if (!UsedSymbols.empty()) {
+    HI.UsedSymbols = std::optional<std::set<UsedSymbol>>{std::move(UsedSymbols)};
+  }
+}
 } // namespace
 
 std::optional<HoverInfo> getHover(ParsedAST &AST, Position Pos,
                                   const format::FormatStyle &Style,
                                   const SymbolIndex *Index) {
   PrintingPolicy PP =
       getPrintingPolicy(AST.getASTContext().getPrintingPolicy());
   const SourceManager &SM = AST.getSourceManager();
   auto CurLoc = sourceLocationInMainFile(SM, Pos);
   if (!CurLoc) {
     llvm::consumeError(CurLoc.takeError());
     return std::nullopt;
   }
   const auto &TB = AST.getTokens();
   auto TokensTouchingCursor = syntax::spelledTokensTouching(*CurLoc, TB);
   // Early exit if there were no tokens around the cursor.
   if (TokensTouchingCursor.empty())
     return std::nullopt;
 
+  const auto &Macros = collectMacroReferences(AST);
   // Show full header file path if cursor is on include directive.
   for (const auto &Inc : AST.getIncludeStructure().MainFileIncludes) {
     if (Inc.Resolved.empty() || Inc.HashLine != Pos.line)
       continue;
     HoverInfo HI;
     HI.Name = std::string(llvm::sys::path::filename(Inc.Resolved));
     // FIXME: We don't have a fitting value for Kind.
     HI.Definition =
         URIForFile::canonicalize(Inc.Resolved, AST.tuPath()).file().str();
     HI.DefinitionLanguage = "";
+    addUsedSymbols(Inc, AST, Macros, HI);
     return HI;
   }
 
   // To be used as a backup for highlighting the selected token, we use back as
   // it aligns better with biases elsewhere (editors tend to send the position
   // for the left of the hovered token).
   CharSourceRange HighlightRange =
       TokensTouchingCursor.back().range(SM).toCharRange(SM);
if (!Definition.empty()) {
       }
 
       Buffer += Definition;
     }
 
     Output.addCodeBlock(Buffer, DefinitionLanguage);
   }
 
+  if (UsedSymbols) {
+    Output.addRuler();
+    markup::Paragraph &Title = Output.addParagraph();
+    Title.appendText("Provides symbols used in this file:");
+    markup::BulletList &BL = Output.addBulletList();
+    
+    for (const auto &Sym : *UsedSymbols) {
+      markup::Document &D = BL.addItem();
+      markup::Paragraph &P = D.addParagraph();
+      P.appendCode(Sym.Name);
+      P.appendSpace();
+      P.appendText("[Ln: ");
+      P.appendText(std::to_string(Sym.Pos.line));
+      P.appendText(", Col: ");
+      P.appendText(std::to_string(Sym.Pos.character));
+      P.appendText("]");
+    }
+  }
+
   return Output;
 }
 
 // If the backtick at `Offset` starts a probable quoted range, return the range
 // (including the quotes).
 std::optional<llvm::StringRef> getBacktickQuoteRange(llvm::StringRef Line,
                                                      unsigned Offset) {
   assert(Line[Offset] == '`');