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

[VitaNuo]

Finish the test.

[hokein]

clang-tools-extra/clangd/Hover.cpp

1133

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?

1137

we need to check whether the dyn_cast is a null

1150

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).

1158

the indentation seems wrong here.

1163

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.

1440

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?

1441

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

3144

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

3154

nit: please fix the code indentation.

[VitaNuo]

Address review comments.

[VitaNuo]

Thanks for the comments!

clang-tools-extra/clangd/Hover.cpp

1150

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 :)

1163

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

1440

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

1150

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?

1164

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.

1168

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

1442

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

3143

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

1164

Oh right, sorry.

1442

Sure, thank you.

[hokein]

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

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

3139

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?

3145

can you add a macro FOO to the test?

3148

nit: remove the unused [[]].

3151

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).

3155

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).

3162

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

1165

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.

1166

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.

1190

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

1166

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.

1190

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

3151

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

1164

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

1169

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

1169

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

1164

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.

1169

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

59

nit: this is unused now.

1166

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.

1177

nit: my personal preference would be using break here.

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

3166

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

1166

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;
+  // Set when hovering over the #include line. Contains the names of symbols
+  // from a #include'd file that are used in the main file.
+  std::optional<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/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 <optional>
+#include <set>
 #include <string>
 #include <vector>
 
 namespace clang {
 namespace clangd {
 namespace {
 
 PrintingPolicy getPrintingPolicy(PrintingPolicy Base) {
if (H.kind() == include_cleaner::Header::Physical &&
       break;
 
     // Pick the best-ranked non-included provider
     HI.Provider = spellHeader(AST, SM.getFileEntryForID(SM.getMainFileID()), H);
     break;
   }
 }
 
+std::string getRefName(include_cleaner::SymbolReference Ref) {
+  std::string Name;
+  switch (Ref.Target.kind()) {
+  case include_cleaner::Symbol::Declaration:
+    Name = llvm::dyn_cast<NamedDecl>(&Ref.Target.declaration())
+               ->getDeclName()
+               .getAsString();
+    break;
+  case include_cleaner::Symbol::Macro:
+    Name = Ref.Target.macro().Name->getName();
+    break;
+  }
+  return Name;
+}
+
+void maybeAddUsedSymbols(ParsedAST &AST, HoverInfo &HI, const Inclusion &Inc) {
+  const SourceManager &SM = AST.getSourceManager();
+  std::set<std::string> UsedSymbolNames;
+  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 ||
+        !SM.isWrittenInMainFile(SM.getSpellingLoc(Ref.RefLocation))) {
+          return;
+        }
+
+        for (const include_cleaner::Header &H : Providers) {
+          switch (H.kind()) {
+          case include_cleaner::Header::Physical:
+            if (Inc.Resolved == H.physical()->tryGetRealPathName()) 
+              UsedSymbolNames.insert(getRefName(Ref));
+            break;
+          case include_cleaner::Header::Standard:
+            if (Inc.Written == H.standard().name())
+              UsedSymbolNames.insert(getRefName(Ref));
+            break;
+          case include_cleaner::Header::Verbatim:
+            if (Inc.Written == H.verbatim())
+              UsedSymbolNames.insert(getRefName(Ref));
+            break;
+          }
+        }
+      });
+
+  if (!UsedSymbolNames.empty())
+    HI.UsedSymbolNames = std::optional<std::vector<std::string>>{
+        {UsedSymbolNames.begin(), UsedSymbolNames.end()}};
+}
+
 } // 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;
 
   // 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 = "";
+    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);
if (!Definition.empty()) {
       }
 
       Buffer += Definition;
     }
 
     Output.addCodeBlock(Buffer, DefinitionLanguage);
   }
 
+  if (UsedSymbolNames) {
+    Output.addRuler();
+    markup::Paragraph &P = Output.addParagraph();
+    P.appendText("provides ");
+
+    for (unsigned I = 0; I < UsedSymbolNames->size() - 1 && I < 4; I++) {
+      P.appendCode((*UsedSymbolNames)[I]);
+      P.appendText(", ");
+    }
+
+    P.appendCode((*UsedSymbolNames)[UsedSymbolNames->size() - 1]);
+    if (UsedSymbolNames->size() > 5) {
+      P.appendText(" and ");
+      P.appendText(std::to_string(UsedSymbolNames->size() - 5));
+      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

 void setIncludeCleanerAnalyzesStdlib(bool B);
 
 include_cleaner::Includes
 convertIncludes(const SourceManager &SM,
                 const llvm::ArrayRef<Inclusion> MainFileIncludes);
 
 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

for (const auto *Inc : UnusedIncludes) {
     auto &F = D.Fixes.emplace_back();
     F.Message = "remove #include directive";
     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;
 }
-} // namespace
 
 include_cleaner::Includes
 convertIncludes(const SourceManager &SM,
                 const llvm::ArrayRef<Inclusion> MainFileIncludes) {
   include_cleaner::Includes Includes;
   for (const Inclusion &Inc : MainFileIncludes) {
     include_cleaner::Include TransformedInc;
     llvm::StringRef WrittenRef = llvm::StringRef(Inc.Written);

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 <optional>
 #include <string>
 #include <vector>
 
 namespace clang {
 namespace clangd {
 namespace {
 
 using PassMode = HoverInfo::PassType::PassMode;
const std::function<void(HoverInfo &)> ExpectedBuilder;
            R"cpp(
                   #include "bar.h"
                   #include "foo.h"
                   #include "foobar.h"
                   int F = [[foo^]]();
                 )cpp"),
        "int foo();", "#include \"foo.h\"", "#include \"foo.h\"",
        [](HoverInfo &HI) { HI.Provider = "\"foo.h\""; }},
-       {Annotations(
            R"cpp(
                  #include "foo.h"
 
                  Foo [[f^oo]] = 42;
                 )cpp"),
        R"cpp(
         class Foo {
           public:
           Foo(int val): val(val) {}
           private:
             int val;
         };
-       )cpp", "", "", [](HoverInfo &HI) { HI.Provider = ""; }},
-       {Annotations(
+       )cpp",
+       "", "", [](HoverInfo &HI) { HI.Provider = ""; }},
            R"cpp(
                 #include "bar.h"
                 
                 int F = [[f^oo]](); 
             )cpp"),
        R"cpp(
           int foo();
-       )cpp", "#include \"foo.h\"", "", [](HoverInfo &HI) { HI.Provider = "\"foo.h\""; }},
-       {Annotations(
+       )cpp",
+       "#include \"foo.h\"", "",
+       [](HoverInfo &HI) { HI.Provider = "\"foo.h\""; }},
            R"cpp(
                 #include "bar.h"
             
                 int F = [[f^oo]](); 
             )cpp"),
        "int foo();",
-        R"cpp(
           #include "foo.h"
           #include "foobar.h"
 
-        )cpp", "int foo();", [](HoverInfo &HI) { HI.Provider = "\"foo.h\""; }},
-        {Annotations(
+        )cpp",
+       "int foo();", [](HoverInfo &HI) { HI.Provider = "\"foo.h\""; }},
            R"cpp(
                 #include "bar.h"
             
                 int F = [[f^oo]](); 
             )cpp"),
        R"cpp(
           #include "foobar.h"
-       )cpp", R"cpp(
+       )cpp",
+       R"cpp(
           #include "foo.h"
           #include "foobar.h"
 
-        )cpp", "int foo();", [](HoverInfo &HI) { HI.Provider = "\"foobar.h\""; }},
+        )cpp",
+       "int foo();", [](HoverInfo &HI) { HI.Provider = "\"foobar.h\""; }},
       {Annotations(
            R"cpp(
                   #include "foo.h"
                   int F = [[^MACRO]];
                 )cpp"),
-       "#define MACRO 5",
-       "", "",
+       "#define MACRO 5", "", "",
        [](HoverInfo &HI) { HI.Provider = "\"foo.h\""; }},
       {Annotations(
            R"cpp(
                   #include "bar.h"
                   #include "foo.h"
 
                   int F = [[M^ACRO]];
                 )cpp"),
-       "#define MACRO 5",
-       "#define MACRO 10", "",
+       "#define MACRO 5", "#define MACRO 10", "",
        [](HoverInfo &HI) { HI.Provider = "\"foo.h\""; }},
       {Annotations(
            R"cpp(
                   #include "bar.h"
                   #include "foo.h"
 
                   int F = [[MA^CRO]](5);
                 )cpp"),
-       "#define MACRO(X) X+1",
-       "#include \"foobar.h\"", "#define MACRO(X) X+3",
+       "#define MACRO(X) X+1", "#include \"foobar.h\"", "#define MACRO(X) X+3",
        [](HoverInfo &HI) { HI.Provider = "\"foo.h\""; }},
       {Annotations(
            R"cpp(
                   #include "foo.h"
                   int [[^F]] = MACRO(5);
                 )cpp"),
-       "#define MACRO(X) (X+1)",
-       "", "",
+       "#define MACRO(X) (X+1)", "", "",
        [](HoverInfo &HI) { HI.Provider = ""; }},
       {Annotations(
            R"cpp(
                   #include "bar.h"    
                   int F = [[MACR^O]];
                 )cpp"),
        "#define MACRO 5", "#include \"foo.h\"", "",
        [](HoverInfo &HI) { HI.Provider = "\"foo.h\""; }},
-       {Annotations(
            R"cpp(
                   #include "bar.h"    
                   int F = [[MACR^O]];
                 )cpp"),
        "#define MACRO 5", R"cpp(
         #include "foo.h"
         #include "foobar.h"
-      )cpp", "#define MACRO 10",
-       [](HoverInfo &HI) { HI.Provider = "\"foobar.h\""; }},
-       {Annotations(
+      )cpp",
+       "#define MACRO 10", [](HoverInfo &HI) { HI.Provider = "\"foobar.h\""; }},
            R"cpp(
             #include "bar.h"    
             
             int F = [[fo^o]]();
           )cpp"),
        "", R"cpp(
         // IWYU pragma: private, include "foo.h"
         int foo();
-      )cpp", "",
-       [](HoverInfo &HI) { HI.Provider = "\"bar.h\""; }},
-       {Annotations(
+      )cpp",
+       "", [](HoverInfo &HI) { HI.Provider = "\"bar.h\""; }},
            R"cpp(
             #include "bar.h"    
             
             int F = [[fo^o]]();
           )cpp"),
        "", "#include \"foobar.h\"",
        R"cpp(
         // IWYU pragma: private, include "public.h"
         int foo();
       )cpp",
        [](HoverInfo &HI) { HI.Provider = "\"public.h\""; }},
-       {Annotations(
            R"cpp(
             #include "bar.h"    
             
             std::[[vect^or]] v;
           )cpp"),
        R"cpp(
         namespace std {
           class vector {};
         }
-       )cpp", "#include \"foo.h\"",
-      "",
+       )cpp",
+       "#include \"foo.h\"", "",
        [](HoverInfo &HI) { HI.Provider = "<vector>"; }},
-       {Annotations(
            R"cpp(
             #include "foo.h"    
             
             Foo A;
             Foo B;
             Foo C = A [[^+]] B;
 
           )cpp"),
        R"cpp(
         class Foo {};
         Foo& operator+(const Foo &lhs, const Foo &rhs);
-       )cpp", "#include \"foo.h\"",
-      "",
-       [](HoverInfo &HI) { HI.Provider = "\"foo.h\""; }}
-       };
+       )cpp",
+       "#include \"foo.h\"", "",
+       [](HoverInfo &HI) { HI.Provider = "\"foo.h\""; }}};
 
   for (const auto &Case : Cases) {
     SCOPED_TRACE(Case.Code.code());
 
     TestTU TU;
     TU.Filename = "foo.cpp";
     TU.Code = Case.Code.code();
     TU.AdditionalFiles["foo.h"] = guard(Case.FooHeader);
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, NoProviderIfOtherDeclUsedForHoverCard) {
   Annotations Code(R"cpp(
     #include "absl_string_view.h"
     absl::str^ing_view abc; // hover on string_view
   )cpp");
   llvm::StringLiteral AbslHeader = R"cpp(
     #include "std_string_view.h"
     namespace absl {
       using std::string_view;
   })cpp";
-   llvm::StringLiteral StdHeader = R"cpp(
     namespace std {
       class string_view {};
   })cpp";
 
   TestTU TU;
   TU.Filename = "main.cpp";
   TU.Code = Code.code();
   TU.AdditionalFiles["absl_string_view.h"] = guard(AbslHeader);
   TU.AdditionalFiles["std_string_view.h"] = guard(StdHeader);
 
   auto AST = TU.build();
   auto H = getHover(AST, Code.point(), format::getLLVMStyle(), nullptr);
   ASSERT_TRUE(H);
   EXPECT_EQ(H->Provider, "<string_view>");
 }
 
+TEST(Hover, UsedSymbols) {
+  struct {
+    Annotations Code;
+    llvm::StringLiteral FooHeader;
+    llvm::StringLiteral BarHeader;
+    llvm::StringLiteral SystemHeader;
+    const std::function<void(HoverInfo &)> ExpectedBuilder;
+  } Cases[] = {{Annotations(R"cpp(
+      [[#inclu^de "foo.h"]]            
+      
+      int var = foo();
+    )cpp"),
+                "int foo();", "", "",
+                [](HoverInfo &HI) { HI.UsedSymbolNames = {"foo"}; }},
+               {Annotations(R"cpp(
+      [[^#include "foo.h"]]            
+      
+      int var = foo();
+    )cpp"),
+                "int foo();", "", "",
+                [](HoverInfo &HI) { HI.UsedSymbolNames = {"foo"}; }},
+               {Annotations(R"cpp(
+      [[#include "fo^o.h"]]            
+      
+      int var = foo();
+    )cpp"),
+                "int foo();", "", "",
+                [](HoverInfo &HI) { HI.UsedSymbolNames = {"foo"}; }},
+               {Annotations(R"cpp(
+      [[#include "foo.h"^]]            
+      
+      int var = foo();
+    )cpp"),
+                "int foo();", "", "",
+                [](HoverInfo &HI) { HI.UsedSymbolNames = {"foo"}; }},
+               {Annotations(R"cpp(
+      #include "foo.h"  
+      [[#incl^ude "bar.h"]]
+      
+      int var = foo();
+    )cpp"),
+                "int foo();", "int bar();", "",
+                [](HoverInfo &HI) { HI.UsedSymbolNames = {}; }},
+               {Annotations(R"cpp(
+      #include "foo.h"  
+      [[#include ^"bar.h"]]
+      
+      int fooVar = foo();
+      int barVar = bar();
+      int foobarVar = foobar();
+
+      X x;
+    )cpp"),
+                "int foo();", "int bar(); int foobar(); class X {};", "",
+                [](HoverInfo &HI) {
+                  HI.UsedSymbolNames = {"X", "bar", "foobar"};
+                }},
+               {Annotations(R"cpp(
+            [[#in^clude <foo>]]
+
+            int fooVar = foo();
+          )cpp"),
+                "", "",
+                R"cpp(
+          int foo();
+        )cpp",
+                [](HoverInfo &HI) { HI.UsedSymbolNames = {"foo"}; }},
+               {Annotations(R"cpp(
+            [[#in^clude "bar.h"]]
+            #include "foo.h"
+
+            int fooVar = foo();
+          )cpp"),
+                R"cpp(
+          // IWYU pragma: private, include "bar.h"
+          int foo(); 
+       )cpp",
+                "", "", [](HoverInfo &HI) { HI.UsedSymbolNames = {"foo"}; }}};
+  for (const auto &Case : Cases) {
+    SCOPED_TRACE(Case.Code.code());
+
+    TestTU TU;
+    TU.Filename = "foo.cpp";
+    TU.Code = Case.Code.code();
+    TU.AdditionalFiles["foo.h"] = guard(Case.FooHeader);
+    TU.AdditionalFiles["bar.h"] = guard(Case.BarHeader);
+    TU.AdditionalFiles["system/foo"] = guard(Case.SystemHeader);
+    TU.ExtraArgs.push_back("-isystem" + testPath("system"));
+
+    auto AST = TU.build();
+    auto H = getHover(AST, Case.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;