[clangd] Show used symbols on #include line hover.

[VitaNuo]

Finish the test.

[hokein]

clang-tools-extra/clangd/Hover.cpp

1143

we have a similar function symbolName in include-cleaner's FindHeaders.cpp, but it is not exposed. I think it would be nice to share the implementation (probably add a name() method in the include_cleaner::Symbol structure). No action required, can you add a FIXME here?

1147

we need to check whether the dyn_cast is a null

1160

just want to check the intention, we're using the set here because we want an alphabet order of UsedSymbolNames. If yes, then looks good (probably add a comment in the field UsedSymbolNames of HoverInfo).

1168

the indentation seems wrong here.

1173

since we expose convertIncludes in your previous patch, we can construct a include_cleaner::Includes struct from the parssing Inc, and use the match() method to match the header.

1459

if the UsedSymbolNames.size() > 5, we will show the last element rather than the fifth one, my reading of the code this is not intended, right?

1460

let's abstract a const variable e.g. SymbolNamesLimit for this magic number 5, and use it in all related places

clang-tools-extra/clangd/Hover.h

116

we can use just a vector, we can use .empty() to the unused-include case.

llvm::SmallVector is preferred, per https://llvm.org/docs/ProgrammersManual.html#llvm-adt-smallvector-h.

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

2989

the [[]] range doesn't seem to be used, remove?

2999

nit: please fix the code indentation.

[VitaNuo]

Address review comments.

[VitaNuo]

Thanks for the comments!

clang-tools-extra/clangd/Hover.cpp

1160

Actually no, we're using set primarily to deduplicate symbol names. Otherwise, many symbols have multiple references each, and the resulting list of used symbols ends up having a lot of duplicates.

I didn't know a set would order used symbols names alphabetically, but if so, that's a nice side effect :)

1173

Yeah, good idea, this makes the function considerably shorter.

1459

Right, sorry. That was only covering the case of UsedSymbolNames.size() <= 5.

clang-tools-extra/clangd/Hover.h

116

Ok for std::optional removal, but I wouldn't want to use llvm::SmallVector. HoverInfo does not contain any LLVM types atm (most of the fields are either std::string or std::vector), so I am not sure we want to introduce a divergence for unclear benefit.

[hokein]

clang-tools-extra/clangd/Hover.cpp

1160

yeah, if duplication is the only purpose, then llvm::DenseSet (which is based on a hash-table, thus elements are not sorted) is preferred. The bonus point of using std::set (which is based on the red-black tree) is that the elements are sorted.

I think it would be nice to keep the result sorted (either by the ref range, or the symbol name), using symbol name seems fine to me, can you add a comment for UsedSymbolNames field to clarify that it is sorted by the symbol name?

1174

can you move it out of the callback? otherwise we will construct an include_cleaner::Includes every time when the callback is invoked, which is an unnecessary cost.

1178

nit: inline the Matches in the if body, if (!ConvertedIncludes.match(H).empty())

1461

I think it'd be better to move this into the above for loop (adding a special logic) rather than having a non-trivial handling for the last element.

What do you think about the something like below (it has less usages of .size() and SymbolNamesLimit-1)

auto Fronts = llvm::ArrayRef(UsedSymbolNames).take_front(std::min(UnusedSymbolNames.size(), SymbolNamesLimit));

for (const auto& Sym : Fronts) {
   P.appendCode(Sym);
   if (Sym != Fronts.back())
     P.appendText(", ");
}

if (UsedSymbolNames.size() > Fronts.size()) {
    P.appendText(" and ");
    P.appendText(std::to_string(UsedSymbolNames.size() - Fronts.size()));
    P.appendText(" more");
}

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

24

the newly-introduced code doesn't seem to use the std::optional symbol

2988

nit: fix the indentation (align with the one using in this file), see my comment in your other patch.

[VitaNuo]

Address review comments.

[VitaNuo]

Thanks for the comments!

clang-tools-extra/clangd/Hover.cpp

1174

Oh right, sorry.

1461

Sure, thank you.

[hokein]

thanks, the implementation looks good. I left some comments around the test.

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

2984

Can you add a test in the existing TEST(Hover, Present) to verify the present() method work as expected when the number provided symbols <= 5/ > 5?

2990

can you add a macro FOO to the test?

2993

nit: remove the unused [[]].

2996

IIUC, this test is to test multiple symbols provided by a header, I would suggest removing the foo.h, and just keep bar.h (to reduce the noise from the test).

3000

It is not quite obvious to readers that foobar, and X is from the bar.h, maybe use some more obvious name (e.g. defining classes named Bar1, Bar2 etc).

3007

This test is to test the system header, I'd simulate it more further to reflect the reality. Let's use <vector>, and a system/vector file with the dummy content namespace std { template<typename> class vector {}; }

[kadircet]

(pardon the interruption, some drive-by comments :))

clang-tools-extra/clangd/Hover.cpp

1175

note that we don't care about each reference of a target, so speed things up (rather than going through each reference inside the main file), you can check if you've seen Ref.Target before and skip processing providers in that case.

1176

note that this will attribute a symbol to it's non-preferred providers too, e.g. if you have:
h1.h:

struct Foo; // defined in foo.h
struct Bar; // defined in bar.h
struct Baz; // defined in baz.h
struct H1 {};

I believe we want the following:
main.cc:

#include foo.h // Provides Foo
#include bar.h // Provides Bar
#include h1.h // Provides Baz, H1

Foo *x;
Bar *y;
Baz *z;
H1 *h;

and not saying that h1.h provides all Foo, Bar, Baz and H1 (otherwise an LLVM header will always provide dozens of symbols, e.g. https://github.com/llvm/llvm-project/blob/main/clang/include/clang/AST/Type.h#L109)

Basically in addition to checking that the particular header we're interested in being a provider, we should also be checking there were no other providers that are mentioned in the main file with a higher rank.

1203

can you introduce a trace::metric here for tracking hover distributions on certain symbol types? you can see an example in https://github.com/llvm/llvm-project/blob/main/clang-tools-extra/clangd/XRefs.cpp#L352

i believe the cases we care about are:

• include
• macro
• keyword
• expr
• decl
• attribute

(so that we have some idea about how often we provide this information)

[VitaNuo]

Address review comments.

[VitaNuo]

Thanks for the comments!

clang-tools-extra/clangd/Hover.cpp

1176

Yeah I know that and I've actually assumed until now that it's the correct behavior :) I.e., that we would like to report all the possible providers as providing the symbol, not only the highest ranked one.

But what you're saying makes sense too. See the updated version. Also added a smaller version of the above as a test case.

1203

Ok. This goes a bit out of scope, but I hope we won't get too bogged down in this. Have a look, I hope I understood the API correctly.

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

2996

Ok, I will join it with the foo.h testcase then, because they've become the same thing essentially.

[VitaNuo]

Add a couple more macro test cases.

[VitaNuo]

Remove extra check (already done in walkUsed).

[kadircet]

clang-tools-extra/clangd/Hover.cpp

1174

creating these symbol names for every reference is still a lot of waste, you can directly cache Ref.Target pointers, which are a lot cheaper. you can also store them in an llvm::DenseSet<const Decl*> (std::set has O(logN) operation times). afterwards you can call getRefName only once, on the decls that we care about, and llvm::sort the result.

also because you're using just the declname, we might get erroneous de-duplication (symbols might have same name under different qualifiers) and all of a sudden ns1::Foo might suppress the analysis of ns2::Foo because logic here will think we've already seen a symbol named Foo

1179

you can't actually keep a reference here, return is a value type. just auto MatchingIncludes = ..;

1179

nit: this might read easier with:

auto MatchingIncludes = ConvertedMainFileIncludes.match(H);
// No match for this provider in the main file.
if (MatchingIncludes.empty())
  continue;
// Check if our include matched this provider.
for (auto *MatchingInc : MatchingIncludes) {
  if (MatchingInc->Line == Inc.HashLine + 1)
    UsedSymbolNames.insert(getRefName(Ref));
// Don't look for rest of the providers once we've found a match in the main file.
break;
}

[VitaNuo]

Address review comments.

[VitaNuo]

Thanks for the comments, see the updated version.

clang-tools-extra/clangd/Hover.cpp

1174

Ok, I am storing include_cleaner::Symbols now (not the Decls, since those would require a switch on the symbol kind, etc.) and llvm::sort'ing the result then.

1179

for (auto *MatchingInc : MatchingIncludes) {
  if (MatchingInc->Line == Inc.HashLine + 1)
    UsedSymbolNames.insert(getRefName(Ref));
}

I'm not sure I agree that this snippet is better. It's more verbose than the current version, and IMO matching the hovered include against the provider is quite readable already.

I'm using your suggestions for the comments now, thanks.

[hokein]

thanks, looks good from my side.

clang-tools-extra/clangd/Hover.cpp

62

nit: this is unused now.

1176

thanks for raising it (I didn't think too much about this case).

and not saying that h1.h provides all Foo, Bar, Baz and H1 (otherwise an LLVM header will always provide dozens of symbols, e.g. https://github.com/llvm/llvm-project/blob/main/clang/include/clang/AST/Type.h#L109)

Agree that for this case, we should prevent providing dozens of forward-declared symbols.

But the combination behavior of the unused diagnotics and hover can be confusing for case where h1.h provides all forward declarations and it is not the highest provider in any symbol refs of main.cc, so we will:

1. h1.h is considered as used -> no unused-include diagnostic
2. hover on h1.h doesn't show any provided symbols

My mental model of 2) is that it indicates h1.h is not used, which seems to conflict with 1). Maybe we can think it as a feature, for this case, it is safe to remove this header.

1187

nit: my personal preference would be using break here.

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

3011

it would be nice to have a comment explaining why we show nothing here (because we have a higher provider bar.h)

[kadircet]

thanks the pieces i looked at LG too

[VitaNuo]

Address review comments.

clang-tools-extra/clangd/Hover.cpp

1176

No solution here, just a comment: this seems to go along the lines of our discussion in the sync today, i.e., that we might want to make the unused include analysis stricter eventually. So it seems like the general tendency might be towards making the unused include analysis stricter, rather than showing more provided symbols on hover.

clang-tools-extra/clangd/Hover.h

 #define LLVM_CLANG_TOOLS_EXTRA_CLANGD_HOVER_H
 
 #include "ParsedAST.h"
 #include "Protocol.h"
 #include "support/Markup.h"
 #include "clang/Index/IndexSymbol.h"
 #include <optional>
 #include <string>
+#include <vector>
 
 namespace clang {
 namespace clangd {
 
 /// 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 PassType {
     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;
   };
   // Set only if CalleeArgInfo is set.
   std::optional<PassType> CallPassType;
+  // Filled when hovering over the #include line. Contains the names of symbols
+  // from a #include'd file that are used in the main file, sorted in
+  // alphabetical order.
+  std::vector<std::string> UsedSymbolNames;
 
   /// Produce a user-readable information.
   markup::Document present() const;
 };
 
 inline bool operator==(const HoverInfo::PrintedType &LHS,
                        const HoverInfo::PrintedType &RHS) {
   return std::tie(LHS.Type, LHS.AKA) == std::tie(RHS.Type, RHS.AKA);

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 "Headers.h"
 #include "IncludeCleaner.h"
 #include "ParsedAST.h"
 #include "Selection.h"
 #include "SourceCode.h"
 #include "clang-include-cleaner/Analysis.h"
 #include "clang-include-cleaner/Types.h"
 #include "index/SymbolCollector.h"
 #include "support/Logger.h"

 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/OperationKinds.h"
 #include "clang/AST/PrettyPrinter.h"
 #include "clang/AST/RecordLayout.h"
 #include "clang/AST/Type.h"
 #include "clang/Basic/CharInfo.h"
+#include "clang/Basic/LLVM.h"
 #include "clang/Basic/SourceLocation.h"
+#include "clang/Basic/SourceManager.h"
 #include "clang/Basic/Specifiers.h"
 #include "clang/Basic/TokenKinds.h"
 #include "clang/Index/IndexSymbol.h"
 #include "clang/Tooling/Syntax/Tokens.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/ScopedPrinter.h"
 #include "llvm/Support/raw_ostream.h"
+#include <algorithm>
 #include <optional>
 #include <string>
 #include <vector>
 
 namespace clang {
 namespace clangd {
 namespace {
 
 PrintingPolicy getPrintingPolicy(PrintingPolicy Base) {
   Base.AnonymousTagLocations = false;
if (H.kind() == include_cleaner::Header::Physical &&
       H.physical() == SM.getFileEntryForID(SM.getMainFileID()))
     // Do not show main file as provider, otherwise we'll show provider info
     // on local variables, etc.
     return;
 
   HI.Provider = spellHeader(AST, SM.getFileEntryForID(SM.getMainFileID()), H);
 }
 
+// FIXME: similar functions are present in FindHeaders.cpp (symbolName)
+// and IncludeCleaner.cpp (getSymbolName). Introduce a name() method into
+// include_cleaner::Symbol instead.
+std::string getSymbolName(include_cleaner::Symbol Sym) {
+  std::string Name;
+  switch (Sym.kind()) {
+  case include_cleaner::Symbol::Declaration:
+    if (const auto *ND = llvm::dyn_cast<NamedDecl>(&Sym.declaration()))
+      Name = ND->getDeclName().getAsString();
+    break;
+  case include_cleaner::Symbol::Macro:
+    Name = Sym.macro().Name->getName();
+    break;
+  }
+  return Name;
+}
+
+void maybeAddUsedSymbols(ParsedAST &AST, HoverInfo &HI, const Inclusion &Inc) {
+  const SourceManager &SM = AST.getSourceManager();
+  const auto &ConvertedMainFileIncludes =
+      convertIncludes(SM, AST.getIncludeStructure().MainFileIncludes);
+  const auto &HoveredInclude = convertIncludes(SM, llvm::ArrayRef{Inc});
+  llvm::DenseSet<include_cleaner::Symbol> UsedSymbols;
+  include_cleaner::walkUsed(
+      AST.getLocalTopLevelDecls(), collectMacroReferences(AST),
+      AST.getPragmaIncludes(), SM,
+      [&](const include_cleaner::SymbolReference &Ref,
+          llvm::ArrayRef<include_cleaner::Header> Providers) {
+        if (Ref.RT != include_cleaner::RefType::Explicit ||
+            UsedSymbols.find(Ref.Target) != UsedSymbols.end())
+          return;
+
+        for (const include_cleaner::Header &H : Providers) {
+          auto MatchingIncludes = ConvertedMainFileIncludes.match(H);
+          // No match for this provider in the main file.
+          if (MatchingIncludes.empty())
+            continue;
+
+          // Check if the hovered include matches this provider.
+          if (!HoveredInclude.match(H).empty())
+            UsedSymbols.insert(Ref.Target);
+
+          // Don't look for rest of the providers once we've found a match
+          // in the main file.
+          break;
+        }
+      });
+
+  for (const auto &UsedSymbolDecl : UsedSymbols)
+    HI.UsedSymbolNames.push_back(getSymbolName(UsedSymbolDecl));
+  llvm::sort(HI.UsedSymbolNames);
+}
+
 } // namespace
 
 std::optional<HoverInfo> getHover(ParsedAST &AST, Position Pos,
                                   const format::FormatStyle &Style,
                                   const SymbolIndex *Index) {
+  static constexpr trace::Metric HoverCountMetric(
+      "hover", trace::Metric::Counter, "case");
   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;
 
   // 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;
+    HoverCountMetric.record(1, "include");
     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 = "";
+    maybeAddUsedSymbols(AST, HI, Inc);
     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);
   std::optional<HoverInfo> HI;
   // Macros and deducedtype only works on identifiers and auto/decltype keywords
   // respectively. Therefore they are only trggered on whichever works for them,
   // similar to SelectionTree::create().
   for (const auto &Tok : TokensTouchingCursor) {
     if (Tok.kind() == tok::identifier) {
       // Prefer the identifier token as a fallback highlighting range.
       HighlightRange = Tok.range(SM).toCharRange(SM);
       if (auto M = locateMacroAt(Tok, AST.getPreprocessor())) {
+        HoverCountMetric.record(1, "macro");
         HI = getHoverContents(*M, Tok, AST);
         if (auto DefLoc = M->Info->getDefinitionLoc(); DefLoc.isValid()) {
           include_cleaner::Macro IncludeCleanerMacro{
               AST.getPreprocessor().getIdentifierInfo(Tok.text(SM)), DefLoc};
           maybeAddSymbolProviders(AST, *HI,
                                   include_cleaner::Symbol{IncludeCleanerMacro});
         }
         break;
       }
     } else if (Tok.kind() == tok::kw_auto || Tok.kind() == tok::kw_decltype) {
+      HoverCountMetric.record(1, "keyword");
       if (auto Deduced = getDeducedType(AST.getASTContext(), Tok.location())) {
         HI = getDeducedTypeHoverContents(*Deduced, Tok, AST.getASTContext(), PP,
                                          Index);
         HighlightRange = Tok.range(SM).toCharRange(SM);
         break;
       }
 
       // If we can't find interesting hover information for this
if (!HI) {
     // So our selection tree should be biased right. (Tested with VSCode).
     SelectionTree ST =
         SelectionTree::createRight(AST.getASTContext(), TB, Offset, Offset);
     if (const SelectionTree::Node *N = ST.commonAncestor()) {
       // FIXME: Fill in HighlightRange with range coming from N->ASTNode.
       auto Decls = explicitReferenceTargets(N->ASTNode, DeclRelation::Alias,
                                             AST.getHeuristicResolver());
       if (const auto *DeclToUse = pickDeclToUse(Decls)) {
+        HoverCountMetric.record(1, "decl");
         HI = getHoverContents(DeclToUse, PP, Index, TB);
         // Layout info only shown when hovering on the field/class itself.
         if (DeclToUse == N->ASTNode.get<Decl>())
           addLayoutInfo(*DeclToUse, *HI);
         // Look for a close enclosing expression to show the value of.
         if (!HI->Value)
           HI->Value = printExprValue(N, AST.getASTContext());
         maybeAddCalleeArgInfo(N, *HI, PP);
         maybeAddSymbolProviders(AST, *HI, include_cleaner::Symbol{*DeclToUse});
       } else if (const Expr *E = N->ASTNode.get<Expr>()) {
+        HoverCountMetric.record(1, "expr");
         HI = getHoverContents(N, E, AST, PP, Index);
       } else if (const Attr *A = N->ASTNode.get<Attr>()) {
+        HoverCountMetric.record(1, "attribute");
         HI = getHoverContents(A, AST);
       }
       // FIXME: support hovers for other nodes?
       //  - built-in types
     }
   }
 
   if (!HI)
if (!Definition.empty()) {
       }
 
       Buffer += Definition;
     }
 
     Output.addCodeBlock(Buffer, DefinitionLanguage);
   }
 
+  if (!UsedSymbolNames.empty()) {
+    Output.addRuler();
+    markup::Paragraph &P = Output.addParagraph();
+    P.appendText("provides ");
+
+    const unsigned long SymbolNamesLimit = 5;
+    auto Front =
+        llvm::ArrayRef(UsedSymbolNames)
+            .take_front(std::min(UsedSymbolNames.size(), SymbolNamesLimit));
+
+    for (const auto &Sym : Front) {
+      P.appendCode(Sym);
+      if (Sym != Front.back())
+        P.appendText(", ");
+    }
+
+    if (UsedSymbolNames.size() > Front.size()) {
+      P.appendText(" and ");
+      P.appendText(std::to_string(UsedSymbolNames.size() - Front.size()));
+      P.appendText(" more");
+    }
+  }
+
   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] == '`');

clang-tools-extra/clangd/IncludeCleaner.h

 include_cleaner::Includes
 convertIncludes(const SourceManager &SM,
                 const llvm::ArrayRef<Inclusion> Includes);
 
 /// Determines the header spelling of an include-cleaner header
 /// representation. The spelling contains the ""<> characters.
 std::string spellHeader(ParsedAST &AST, const FileEntry *MainFile,
                         include_cleaner::Header Provider);
+
+std::vector<include_cleaner::SymbolReference>
+collectMacroReferences(ParsedAST &AST);
 } // namespace clangd
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_INCLUDECLEANER_H

clang-tools-extra/clangd/IncludeCleaner.cpp

static bool mayConsiderUnused(const Inclusion &Inc, ParsedAST &AST,
 
   if (isFilteredByConfig(Cfg, Inc.Resolved)) {
     dlog("{0} header is filtered out by the configuration", FE->getName());
     return false;
   }
   return true;
 }
 
-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;
-}
-
 llvm::StringRef getResolvedPath(const include_cleaner::Header &SymProvider) {
   switch (SymProvider.kind()) {
   case include_cleaner::Header::Physical:
     return SymProvider.physical()->tryGetRealPathName();
   case include_cleaner::Header::Standard:
     return SymProvider.standard().name().trim("<>\"");
   case include_cleaner::Header::Verbatim:
     return SymProvider.verbatim().trim("<>\"");
for (const auto *Inc : UnusedIncludes) {
     F.Edits.emplace_back();
     F.Edits.back().range.start.line = Inc->HashLine;
     F.Edits.back().range.end.line = Inc->HashLine + 1;
   }
   return Result;
 }
 } // namespace
 
+
+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;
+}
+
 include_cleaner::Includes
 convertIncludes(const SourceManager &SM,
                 const llvm::ArrayRef<Inclusion> Includes) {
   include_cleaner::Includes ConvertedIncludes;
   for (const Inclusion &Inc : Includes) {
     include_cleaner::Include TransformedInc;
     llvm::StringRef WrittenRef = llvm::StringRef(Inc.Written);
     TransformedInc.Spelled = WrittenRef.trim("\"<>");

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

 //===-- HoverTests.cpp ----------------------------------------------------===//
 //
 // 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 "AST.h"
 #include "Annotations.h"
 #include "Config.h"
 #include "Hover.h"
+#include "TestFS.h"
 #include "TestIndex.h"
 #include "TestTU.h"
 #include "index/MemIndex.h"
 #include "clang/AST/Attr.h"
 #include "clang/Format/Format.h"
 #include "clang/Index/IndexSymbol.h"
 #include "llvm/ADT/StringRef.h"
 
 #include "gtest/gtest.h"
 #include <functional>
 #include <string>
 #include <vector>
 
 namespace clang {
 namespace clangd {
 namespace {
 
 using PassMode = HoverInfo::PassType::PassMode;
 
struct Case {
     llvm::StringRef ExpectedMarkdown;
   } Cases[] = {{HIFoo, "### `foo`  \nprovided by `\"foo.h\"`"},
                {HIFooBar, "### `foo`  \nprovided by `<bar.h>`"}};
 
   for (const auto &Case : Cases)
     EXPECT_EQ(Case.HI.present().asMarkdown(), Case.ExpectedMarkdown);
 }
 
+TEST(Hover, UsedSymbols) {
+  struct {
+    const char *Code;
+    const std::function<void(HoverInfo &)> ExpectedBuilder;
+  } Cases[] = {{R"cpp(
+                  #include ^"bar.h"
+                  int fstBar = bar1();
+                  int sndBar = bar2();
+                  Bar bar;
+                  int macroBar = BAR;
+                )cpp",
+                [](HoverInfo &HI) {
+                  HI.UsedSymbolNames = {"BAR", "Bar", "bar1", "bar2"};
+                }},
+               {R"cpp(
+                  #in^clude <vector>
+                  std::vector<int> vec;
+                )cpp",
+                [](HoverInfo &HI) { HI.UsedSymbolNames = {"vector"}; }},
+               {R"cpp(
+                  #in^clude "public.h"
+                  #include "private.h"
+                  int fooVar = foo();
+                )cpp",
+                [](HoverInfo &HI) { HI.UsedSymbolNames = {"foo"}; }},
+               {R"cpp(
+                  #include "bar.h"
+                  #include "for^ward.h"
+                  Bar *x;
+                )cpp",
+                [](HoverInfo &HI) {
+                  HI.UsedSymbolNames = {
+                      // No used symbols, since bar.h is a higher-ranked
+                      // provider for Bar.
+                  };
+                }},
+               {R"cpp(
+                  #include "b^ar.h"
+                  #define DEF(X) const Bar *X
+                  DEF(a);
+                )cpp",
+                [](HoverInfo &HI) { HI.UsedSymbolNames = {"Bar"}; }},
+               {R"cpp(
+                  #in^clude "bar.h"
+                  #define BAZ(X) const X x
+                  BAZ(Bar);
+                )cpp",
+                [](HoverInfo &HI) { HI.UsedSymbolNames = {"Bar"}; }}};
+  for (const auto &Case : Cases) {
+    Annotations Code{Case.Code};
+    SCOPED_TRACE(Code.code());
+
+    TestTU TU;
+    TU.Filename = "foo.cpp";
+    TU.Code = Code.code();
+    TU.AdditionalFiles["bar.h"] = guard(R"cpp(
+                                          #define BAR 5
+                                          int bar1();
+                                          int bar2();
+                                          class Bar {};
+                                        )cpp");
+    TU.AdditionalFiles["private.h"] = guard(R"cpp(
+                                              // IWYU pragma: private, include "public.h"
+                                              int foo(); 
+                                            )cpp");
+    TU.AdditionalFiles["public.h"] = guard("");
+    TU.AdditionalFiles["system/vector"] = guard(R"cpp(
+      namespace std {
+        template<typename>
+        class vector{};
+      }
+    )cpp");
+    TU.AdditionalFiles["forward.h"] = guard("class Bar;");
+    TU.ExtraArgs.push_back("-isystem" + testPath("system"));
+
+    auto AST = TU.build();
+    auto H = getHover(AST, Code.point(), format::getLLVMStyle(), nullptr);
+    ASSERT_TRUE(H);
+    HoverInfo Expected;
+    Case.ExpectedBuilder(Expected);
+    SCOPED_TRACE(H->present().asMarkdown());
+    EXPECT_EQ(H->UsedSymbolNames, Expected.UsedSymbolNames);
+  }
+}
+
 TEST(Hover, DocsFromIndex) {
   Annotations T(R"cpp(
   template <typename T> class X {};
   void foo() {
     auto t = X<int>();
     X^<int> w;
     (void)w;
   })cpp");
int foo = 3)",
       {
           [](HoverInfo &HI) {
             HI.Name = "stdio.h";
             HI.Definition = "/usr/include/stdio.h";
           },
           R"(stdio.h
 
 /usr/include/stdio.h)",
-      }};
+      },
+      {[](HoverInfo &HI) {
+         HI.Name = "foo.h";
+         HI.UsedSymbolNames = {"Foo", "Bar", "Baz"};
+       },
+       R"(foo.h
+
+provides Foo, Bar, Baz)"},
+      {[](HoverInfo &HI) {
+         HI.Name = "foo.h";
+         HI.UsedSymbolNames = {"Foo", "Bar", "Baz", "Foobar", "Qux", "Quux"};
+       },
+       R"(foo.h
+
+provides Foo, Bar, Baz, Foobar, Qux and 1 more)"}};
 
   for (const auto &C : Cases) {
     HoverInfo HI;
     C.Builder(HI);
     Config Cfg;
     Cfg.Hover.ShowAKA = true;
     WithContextValue WithCfg(Config::Key, std::move(Cfg));
     EXPECT_EQ(HI.present().asPlainText(), C.ExpectedRender);