[include-fixer] Add usage count to find-all-symbols.

[sammccall]

Summary

Add usage count to find-all-symbols.

FindAllSymbols now finds (most!) main-file usages of the discovered symbols.
The per-TU map output provides Signals: Seen (was NumOccurrences) and Used.
These are no longer part of the SymbolInfo. They are provided in batches, deduplicated.
The reducer aggregates these to find the number of files that use a symbol.

The idea here is to use Signals.Used for ranking: intuitively number of files that
use a symbol is more meaningful than number of files that include the header.

[sammccall]

Remove obsolete comment.

[hokein]

Thanks for the contributions!

include-fixer/find-all-symbols/FindAllSymbols.cpp

244–252

The way seems too tricky to me. I'd use a flag variable like isUsedDecl to distinguish and handle use and decl cases.

250

Is the preceding ! intended?

include-fixer/find-all-symbols/SymbolInfo.h

98

A blank between class members.

unittests/include-fixer/find-all-symbols/FindAllSymbolsTests.cpp

46–52

nit: You can use llvm::is_contained here.

50

The same.

64

nit: a blank line between methods.

526

I'd put a FIXME comment here.

553

The same.

[sammccall]

Address review comments.

[sammccall]

Thanks for the review, still learning the style :)

include-fixer/find-all-symbols/FindAllSymbols.cpp

250

This does the right thing (!"string" is always false) but generates a warning.
Changed to assert(false && ...)

[klimek]

include-fixer/find-all-symbols/FindAllSymbols.cpp

260

You can use llvm_unreachable instead. Or do you actually want to fall through in release mode?

include-fixer/find-all-symbols/SymbolInfo.h

94–95

So we map from Symbol to NumOccurences in SymbolInfoMain, but duplicate the info in the key? That seems somewhat weird.

[sammccall]

OK, some changes to come here:

• klimek thinks using a set as a pseudo-map with mutable is evil, which is a fair point
• the current SymbolReporter interface doesn't provide enough information to deduplicate efficiently, so we'll move the dedup to FindAllSymbols instead.

include-fixer/find-all-symbols/SymbolInfo.h

94–95

We no longer do that mapping.

[sammccall]

Changes based on offline discussion:

• mutable SignalInfo data split into SignalInfo::Signals
• yaml serialized data is SignalInfo::WithSignals, which is currently a pair<SignalInfo, Signals>
• FindAllSymbols/FindAllMacros now report in batches, with symbols already deduplicated. This makes it easy to count each (file,symbol) only once.
• implemented macro usages because I had to touch that anyway

[sammccall]

Switch from SymbolInfo::WithSignals as a typedef for std::pair, to a struct
SymbolAndSignals, to have clearer semantics.

[sammccall]

git-clang-format

[hokein]

include-fixer/InMemorySymbolIndex.h

27

There are many places using std::vector<clang::find_all_symbols::SymbolAndSignals>. Maybe we can use a type alias for it, so that we can type less.

include-fixer/SymbolIndexManager.cpp

104

I think you miss & here.

include-fixer/find-all-symbols/FindAllMacros.cpp

37–39

Nit: No {} for single statement in if. The same below.

include-fixer/find-all-symbols/FindAllMacros.h

39

We are missing tests for these macro usages.

include-fixer/find-all-symbols/FindAllSymbols.h

51

s/on EndSourceFileAction/onEndOfTranslationUnit.

include-fixer/find-all-symbols/SymbolInfo.h

50

I think we can make a standalone class instead of making it a nested class of SymbolInfo because I don't see strong relationship between them. Maybe name it FindingSignals or FindingInfo.

71

We don't need this method since we have SymbolAndSignals?

100

I'd put this statement inside SymbolAndSignals.

128–130

Not much better idea on names, how about SymbolFinding?

struct SymbolFinding {
   SymbolInfo Symbol;
   FindingInfo Finding;
};

[sammccall]

Address review comments.

include-fixer/InMemorySymbolIndex.h

27

I guess? It's the namespaces that are the problem (vector<SymbolAndSignals> is fine) and most of the namespace noise wouldn't go away here.

is clang::find_all_symbols::SymbolsSignalsList better enough to obscure what the actual type is? It's 45 chars vs 54.

IMO it's not worth it here, though clang::find_all_symbols::SymbolInfo::SignalMap vs std::map<clang::find_all_symbols::SymbolInfo, clang::find_all_symbols::SymbolInfo::Signals> is.

include-fixer/find-all-symbols/FindAllMacros.h

39

These are covered by FindAllSymbolsTests, which (despite the name) tests the whole FindAllSymbolsAction.

Specifically, MacroTest and MacroTestWithIWYU cover these.

include-fixer/find-all-symbols/SymbolInfo.h

50

The relationship between them is a strong scoping one: signals only make sense in the context of a particular SymbolInfo.

If it was a parallel top-level class, it needs a name that communicates this relationship, most likely SymbolSignals. I don't think that's significantly better than SymbolInfo::Signals.

(If I had my druthers, these would probably be Symbol and Symbol::Signals - the "info" is the main reason that SymbolInfo::Signals is noisy. But not worth the churn I think)

100

That won't compile: it's the members of SymbolInfo that are private, not the members of SymbolAndSignals.

128–130

I don't think SymbolFinding is better:

• it can be misinterpreted as finding *for* a signal, not findings *and* a signal. I think the And is important
• "finding" is vague while "signal" is more specific. I changed this from finding -> signal already based on a discussion with Ben, if you do want to change this we should sync up offline :)

[hokein]

include-fixer/InMemorySymbolIndex.h

27

If we put the type alias under clang::include_fixer namespace, it will shorten the name more. Agree it is not worth the effect as the full name only happens in headers.

We could save a few characters by getting rid of clang because we are always in clang namespace. So std::vector<find_all_symbols::SymbolAndSignals> should work, this looks slightly better. :)

include-fixer/find-all-symbols/FindAllMacros.cpp

38

code style: use prefix ++. The same below.

include-fixer/find-all-symbols/FindAllMacros.h

39

Acked. You combined them in current tests (I originally thought there should be some separate tests for these).

include-fixer/find-all-symbols/SymbolInfo.cpp

78

You forgot to update this?

include-fixer/find-all-symbols/SymbolInfo.h

50

You convinced me. Please keep the comment of Signals updated.

If I had my druthers, these would probably be Symbol and Symbol::Signals - the "info" is the main reason that SymbolInfo::Signals is noisy. But not worth the churn I think)

In the initial design, SymbolInfo merely represents a cpp symbol. But as more features developed, SymbolInfo might be not a good name at the moment. Symbol seems not a better name as LLVM already has many classes named Symbol. We can leave it here.

100

Acked. Thanks for explanations. Sorry for misleading.

128–130

Fair enough. I don't have strong opinion about the name.

[sammccall]

Address review comments; remove redundant namespace qualifiers; format.

[sammccall]

Thanks for bearing with me here :)

include-fixer/InMemorySymbolIndex.h

27

Done, also cleaned up other redundant namespaces in touched files.

[hokein]

Thanks! Looks good from my side.

I'd wait to see whether @bkramer has more comments before commit it.

include-fixer/find-all-symbols/SymbolInfo.h

50

keep the comment of Signals updated.

You are missing this.

[sammccall]

Update comment - oops!

[hokein]

unittests/include-fixer/find-all-symbols/FindAllSymbolsTests.cpp

40

A new catch: NewSymbols should be passed by reference, otherwise a copy will be generated.

[sammccall]

Report symbols by reference.

[hokein]

Thanks, still LGTM with one nit.

include-fixer/find-all-symbols/FindAllSymbols.cpp

262

We don't need std::move right now.

[sammccall]

Remove redundant std::move

[bkramer]

lg

include-fixer/SymbolIndexManager.cpp

156

std::move

include-fixer/find-all-symbols/FindAllMacros.cpp

67

Call me oldschool, but I still prefer FileSymbols.clear()

[sammccall]

Review comments

include-fixer/InMemorySymbolIndex.h

 #include <vector>
 
 namespace clang {
 namespace include_fixer {
 
 /// Xref database with fixed content.
 class InMemorySymbolIndex : public SymbolIndex {
 public:
-  InMemorySymbolIndex(const std::vector<find_all_symbols::SymbolInfo> &Symbols);
+  InMemorySymbolIndex(
+      const std::vector<find_all_symbols::SymbolAndSignals> &Symbols);
 
-  std::vector<clang::find_all_symbols::SymbolInfo>
+  std::vector<find_all_symbols::SymbolAndSignals>
   search(llvm::StringRef Identifier) override;
 
 private:
-  std::map<std::string, std::vector<clang::find_all_symbols::SymbolInfo>>
+  std::map<std::string, std::vector<find_all_symbols::SymbolAndSignals>>
       LookupTable;
 };
 
 } // namespace include_fixer
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_INCLUDE_FIXER_INMEMORYSYMBOLINDEX_H

include-fixer/InMemorySymbolIndex.cpp

 //===-- InMemorySymbolIndex.cpp--------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "InMemorySymbolIndex.h"
 
-using clang::find_all_symbols::SymbolInfo;
+using clang::find_all_symbols::SymbolAndSignals;
 
 namespace clang {
 namespace include_fixer {
 
 InMemorySymbolIndex::InMemorySymbolIndex(
-    const std::vector<SymbolInfo> &Symbols) {
+    const std::vector<SymbolAndSignals> &Symbols) {
   for (const auto &Symbol : Symbols)
-    LookupTable[Symbol.getName()].push_back(Symbol);
+    LookupTable[Symbol.Symbol.getName()].push_back(Symbol);
 }
 
-std::vector<SymbolInfo>
+std::vector<SymbolAndSignals>
 InMemorySymbolIndex::search(llvm::StringRef Identifier) {
   auto I = LookupTable.find(Identifier);
   if (I != LookupTable.end())
     return I->second;
   return {};
 }
 
 } // namespace include_fixer
 } // namespace clang

include-fixer/IncludeFixer.cpp

IncludeFixerContext IncludeFixerSemaSource::getIncludeFixerContext(
   for (const auto &Symbol : MatchedSymbols) {
     std::string FilePath = Symbol.getFilePath().str();
     std::string MinimizedFilePath = minimizeInclude(
         ((FilePath[0] == '"' || FilePath[0] == '<') ? FilePath
                                                     : "\"" + FilePath + "\""),
         SourceManager, HeaderSearch);
     SymbolCandidates.emplace_back(Symbol.getName(), Symbol.getSymbolKind(),
                                   MinimizedFilePath, Symbol.getLineNumber(),
-                                  Symbol.getContexts(),
-                                  Symbol.getNumOccurrences());
+                                  Symbol.getContexts());
   }
   return IncludeFixerContext(FilePath, QuerySymbolInfos, SymbolCandidates);
 }
 
 std::vector<find_all_symbols::SymbolInfo>
 IncludeFixerSemaSource::query(StringRef Query, StringRef ScopedQualifiers,
                               tooling::Range Range) {
   assert(!Query.empty() && "Empty query!");

include-fixer/SymbolIndex.h

 public:
   virtual ~SymbolIndex() = default;
 
   /// Search for all `SymbolInfo`s corresponding to an identifier.
   /// \param Identifier The unqualified identifier being searched for.
   /// \returns A list of `SymbolInfo` candidates.
   // FIXME: Expose the type name so we can also insert using declarations (or
   // fix the usage)
-  virtual std::vector<clang::find_all_symbols::SymbolInfo>
+  virtual std::vector<find_all_symbols::SymbolAndSignals>
   search(llvm::StringRef Identifier) = 0;
 };
 
 } // namespace include_fixer
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_INCLUDE_FIXER_SYMBOLINDEX_H

include-fixer/SymbolIndexManager.cpp

 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Path.h"
 
 #define DEBUG_TYPE "include-fixer"
 
 namespace clang {
 namespace include_fixer {
 
-using clang::find_all_symbols::SymbolInfo;
+using find_all_symbols::SymbolInfo;
+using find_all_symbols::SymbolAndSignals;
 
 // Calculate a score based on whether we think the given header is closely
 // related to the given source file.
 static double similarityScore(llvm::StringRef FileName,
                               llvm::StringRef Header) {
   // Compute the maximum number of common path segements between Header and
   // a suffix of FileName.
   // We do not do a full longest common substring computation, as Header
for (auto HeaderI = llvm::sys::path::begin(Header),
          HeaderI != HeaderE && *I == *HeaderI && I != FileE; ++I, ++HeaderI) {
       ++Segments;
     }
     MaxSegments = std::max(Segments, MaxSegments);
   }
   return MaxSegments;
 }
 
-static void rank(std::vector<SymbolInfo> &Symbols,
+static void rank(std::vector<SymbolAndSignals> &Symbols,
                  llvm::StringRef FileName) {
   llvm::DenseMap<llvm::StringRef, double> Score;
-  for (const SymbolInfo &Symbol : Symbols) {
+  for (const auto &Symbol : Symbols) {
     // Calculate a score from the similarity of the header the symbol is in
     // with the current file and the popularity of the symbol.
-    double NewScore = similarityScore(FileName, Symbol.getFilePath()) *
-                      (1.0 + std::log2(1 + Symbol.getNumOccurrences()));
-    double &S = Score[Symbol.getFilePath()];
+    double NewScore = similarityScore(FileName, Symbol.Symbol.getFilePath()) *
+                      (1.0 + std::log2(1 + Symbol.Signals.Seen));
+    double &S = Score[Symbol.Symbol.getFilePath()];
     S = std::max(S, NewScore);
   }
   // Sort by the gathered scores. Use file name as a tie breaker so we can
   // deduplicate.
   std::sort(Symbols.begin(), Symbols.end(),
-            [&](const SymbolInfo &A, const SymbolInfo &B) {
-              auto AS = Score[A.getFilePath()];
-              auto BS = Score[B.getFilePath()];
+            [&](const SymbolAndSignals &A, const SymbolAndSignals &B) {
+              auto AS = Score[A.Symbol.getFilePath()];
+              auto BS = Score[B.Symbol.getFilePath()];
               if (AS != BS)
                 return AS > BS;
-              return A.getFilePath() < B.getFilePath();
+              return A.Symbol.getFilePath() < B.Symbol.getFilePath();
             });
 }
 
 std::vector<find_all_symbols::SymbolInfo>
 SymbolIndexManager::search(llvm::StringRef Identifier,
                            bool IsNestedSearch,
                            llvm::StringRef FileName) const {
   // The identifier may be fully qualified, so split it and get all the context
   // names.
   llvm::SmallVector<llvm::StringRef, 8> Names;
   Identifier.split(Names, "::");
 
   bool IsFullyQualified = false;
   if (Identifier.startswith("::")) {
     Names.erase(Names.begin()); // Drop first (empty) element.
     IsFullyQualified = true;
   }
 
   // As long as we don't find a result keep stripping name parts from the end.
   // This is to support nested classes which aren't recorded in the database.
   // Eventually we will either hit a class (namespaces aren't in the database
   // either) and can report that result.
   bool TookPrefix = false;
-  std::vector<clang::find_all_symbols::SymbolInfo> MatchedSymbols;
+  std::vector<SymbolAndSignals> MatchedSymbols;
   do {
-    std::vector<clang::find_all_symbols::SymbolInfo> Symbols;
+    std::vector<SymbolAndSignals> Symbols;
     for (const auto &DB : SymbolIndices) {
       auto Res = DB.get()->search(Names.back());
       Symbols.insert(Symbols.end(), Res.begin(), Res.end());
     }
 
     DEBUG(llvm::dbgs() << "Searching " << Names.back() << "... got "
                        << Symbols.size() << " results...\n");
 
-    for (const auto &Symbol : Symbols) {
+    for (auto &SymAndSig : Symbols) {
+      const SymbolInfo &Symbol = SymAndSig.Symbol;
       // Match the identifier name without qualifier.
       if (Symbol.getName() == Names.back()) {
         bool IsMatched = true;
         auto SymbolContext = Symbol.getContexts().begin();
         auto IdentiferContext = Names.rbegin() + 1; // Skip identifier name.
         // Match the remaining context names.
         while (IdentiferContext != Names.rend() &&
                SymbolContext != Symbol.getContexts().end()) {
for (auto &SymAndSig : Symbols) {
           if (TookPrefix &&
               (Symbol.getSymbolKind() == SymbolInfo::SymbolKind::Function ||
                Symbol.getSymbolKind() == SymbolInfo::SymbolKind::Variable ||
                Symbol.getSymbolKind() ==
                    SymbolInfo::SymbolKind::EnumConstantDecl ||
                Symbol.getSymbolKind() == SymbolInfo::SymbolKind::Macro))
             continue;
 
-          MatchedSymbols.push_back(Symbol);
+          MatchedSymbols.push_back(std::move(SymAndSig));
         }
       }
     }
     Names.pop_back();
     TookPrefix = true;
   } while (MatchedSymbols.empty() && !Names.empty() && IsNestedSearch);
 
   rank(MatchedSymbols, FileName);
-  return MatchedSymbols;
+  // Strip signals, they are no longer needed.
+  std::vector<SymbolInfo> Res;
+  for (const auto &SymAndSig : MatchedSymbols)
+    Res.push_back(std::move(SymAndSig.Symbol));
+  return Res;
 }
 
 } // namespace include_fixer
 } // namespace clang

include-fixer/YamlSymbolIndex.h

 public:
   /// Create a new Yaml db from a file.
   static llvm::ErrorOr<std::unique_ptr<YamlSymbolIndex>>
   createFromFile(llvm::StringRef FilePath);
   /// Look for a file called \c Name in \c Directory and all parent directories.
   static llvm::ErrorOr<std::unique_ptr<YamlSymbolIndex>>
   createFromDirectory(llvm::StringRef Directory, llvm::StringRef Name);
 
-  std::vector<clang::find_all_symbols::SymbolInfo>
+  std::vector<find_all_symbols::SymbolAndSignals>
   search(llvm::StringRef Identifier) override;
 
 private:
   explicit YamlSymbolIndex(
-      std::vector<clang::find_all_symbols::SymbolInfo> Symbols)
+      std::vector<find_all_symbols::SymbolAndSignals> Symbols)
       : Symbols(std::move(Symbols)) {}
 
-  std::vector<clang::find_all_symbols::SymbolInfo> Symbols;
+  std::vector<find_all_symbols::SymbolAndSignals> Symbols;
 };
 
 } // namespace include_fixer
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_INCLUDE_FIXER_YAMLSYMBOLINDEX_H

include-fixer/YamlSymbolIndex.cpp

 #include "llvm/Support/Errc.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include <string>
 #include <vector>
 
 using clang::find_all_symbols::SymbolInfo;
+using clang::find_all_symbols::SymbolAndSignals;
 
 namespace clang {
 namespace include_fixer {
 
 llvm::ErrorOr<std::unique_ptr<YamlSymbolIndex>>
 YamlSymbolIndex::createFromFile(llvm::StringRef FilePath) {
   auto Buffer = llvm::MemoryBuffer::getFile(FilePath);
   if (!Buffer)
     return Buffer.getError();
 
-  return std::unique_ptr<YamlSymbolIndex>(
-      new YamlSymbolIndex(clang::find_all_symbols::ReadSymbolInfosFromYAML(
-          Buffer.get()->getBuffer())));
+  return std::unique_ptr<YamlSymbolIndex>(new YamlSymbolIndex(
+      find_all_symbols::ReadSymbolInfosFromYAML(Buffer.get()->getBuffer())));
 }
 
 llvm::ErrorOr<std::unique_ptr<YamlSymbolIndex>>
 YamlSymbolIndex::createFromDirectory(llvm::StringRef Directory,
                                      llvm::StringRef Name) {
   // Walk upwards from Directory, looking for files.
   for (llvm::SmallString<128> PathStorage = Directory; !Directory.empty();
        Directory = llvm::sys::path::parent_path(Directory)) {
     assert(Directory.size() <= PathStorage.size());
     PathStorage.resize(Directory.size()); // Shrink to parent.
     llvm::sys::path::append(PathStorage, Name);
     if (auto DB = createFromFile(PathStorage))
       return DB;
   }
   return llvm::make_error_code(llvm::errc::no_such_file_or_directory);
 }
 
-std::vector<SymbolInfo> YamlSymbolIndex::search(llvm::StringRef Identifier) {
-  std::vector<SymbolInfo> Results;
+std::vector<SymbolAndSignals>
+YamlSymbolIndex::search(llvm::StringRef Identifier) {
+  std::vector<SymbolAndSignals> Results;
   for (const auto &Symbol : Symbols) {
-    if (Symbol.getName() == Identifier)
+    if (Symbol.Symbol.getName() == Identifier)
       Results.push_back(Symbol);
   }
   return Results;
 }
 
 } // namespace include_fixer
 } // namespace clang

include-fixer/find-all-symbols/FindAllMacros.h

 #ifndef LLVM_CLANG_TOOLS_EXTRA_FIND_ALL_SYMBOLS_FIND_ALL_MACROS_H
 #define LLVM_CLANG_TOOLS_EXTRA_FIND_ALL_SYMBOLS_FIND_ALL_MACROS_H
 
 #include "SymbolInfo.h"
 #include "SymbolReporter.h"
 #include "clang/Lex/PPCallbacks.h"
 
 namespace clang {
+class MacroInfo;
 namespace find_all_symbols {
 
 class HeaderMapCollector;
 
 /// \brief A preprocessor that collects all macro symbols.
 /// The contexts of a macro will be ignored since they are not available during
 /// preprocessing period.
 class FindAllMacros : public clang::PPCallbacks {
 public:
   explicit FindAllMacros(SymbolReporter *Reporter, SourceManager *SM,
                          HeaderMapCollector *Collector = nullptr)
       : Reporter(Reporter), SM(SM), Collector(Collector) {}
 
   void MacroDefined(const Token &MacroNameTok,
                     const MacroDirective *MD) override;
 
+  void MacroExpands(const Token &MacroNameTok, const MacroDefinition &MD,
+                    SourceRange Range, const MacroArgs *Args) override;
+
+  void Ifdef(SourceLocation Loc, const Token &MacroNameTok,
+             const MacroDefinition &MD) override;
+
+  void Ifndef(SourceLocation Loc, const Token &MacroNameTok,
+              const MacroDefinition &MD) override;
+
+  void EndOfMainFile() override;
+
 private:
+  llvm::Optional<SymbolInfo> CreateMacroSymbol(const Token &MacroNameTok,
+                                               const MacroInfo *MD);
+  // Not a callback, just a common path for all usage types.
+  void MacroUsed(const Token &Name, const MacroDefinition &MD);
+
+  SymbolInfo::SignalMap FileSymbols;
   // Reporter for SymbolInfo.
   SymbolReporter *const Reporter;
   SourceManager *const SM;
   // A remapping header file collector allowing clients to include a different
   // header.
   HeaderMapCollector *const Collector;
 };
 
 } // namespace find_all_symbols
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_FIND_ALL_SYMBOLS_FIND_ALL_MACROS_H

include-fixer/find-all-symbols/FindAllMacros.cpp

 //===-- FindAllMacros.cpp - find all macros ---------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "FindAllMacros.h"
 #include "HeaderMapCollector.h"
 #include "PathConfig.h"
 #include "SymbolInfo.h"
 #include "clang/Basic/IdentifierTable.h"
 #include "clang/Basic/SourceManager.h"
+#include "clang/Lex/MacroInfo.h"
 #include "clang/Lex/Token.h"
 #include "llvm/Support/Path.h"
 
 namespace clang {
 namespace find_all_symbols {
 
+llvm::Optional<SymbolInfo>
+FindAllMacros::CreateMacroSymbol(const Token &MacroNameTok,
+                                 const MacroInfo *info) {
+  std::string FilePath =
+      getIncludePath(*SM, info->getDefinitionLoc(), Collector);
+  if (FilePath.empty())
+    return llvm::None;
+  return SymbolInfo(MacroNameTok.getIdentifierInfo()->getName(),
+                    SymbolInfo::SymbolKind::Macro, FilePath,
+                    SM->getSpellingLineNumber(info->getDefinitionLoc()), {});
+}
+
 void FindAllMacros::MacroDefined(const Token &MacroNameTok,
                                  const MacroDirective *MD) {
-  SourceLocation Loc = SM->getExpansionLoc(MacroNameTok.getLocation());
-  std::string FilePath = getIncludePath(*SM, Loc, Collector);
-  if (FilePath.empty()) return;
+  if (auto Symbol = CreateMacroSymbol(MacroNameTok, MD->getMacroInfo()))
+    ++FileSymbols[*Symbol].Seen;
+}
 
-  SymbolInfo Symbol(MacroNameTok.getIdentifierInfo()->getName(),
-                    SymbolInfo::SymbolKind::Macro, FilePath,
-                    SM->getSpellingLineNumber(Loc), {});
+void FindAllMacros::MacroUsed(const Token &Name, const MacroDefinition &MD) {
+  if (!MD || !SM->isInMainFile(SM->getExpansionLoc(Name.getLocation())))
+    return;
+  if (auto Symbol = CreateMacroSymbol(Name, MD.getMacroInfo()))
+    ++FileSymbols[*Symbol].Used;
+}
+
+void FindAllMacros::MacroExpands(const Token &MacroNameTok,
+                                 const MacroDefinition &MD, SourceRange Range,
+                                 const MacroArgs *Args) {
+  MacroUsed(MacroNameTok, MD);
+}
+
+void FindAllMacros::Ifdef(SourceLocation Loc, const Token &MacroNameTok,
+                          const MacroDefinition &MD) {
+  MacroUsed(MacroNameTok, MD);
+}
+
+void FindAllMacros::Ifndef(SourceLocation Loc, const Token &MacroNameTok,
+                           const MacroDefinition &MD) {
+  MacroUsed(MacroNameTok, MD);
+}
 
-  Reporter->reportSymbol(SM->getFileEntryForID(SM->getMainFileID())->getName(),
-                         Symbol);
+void FindAllMacros::EndOfMainFile() {
+  Reporter->reportSymbols(SM->getFileEntryForID(SM->getMainFileID())->getName(),
+                          FileSymbols);
+  FileSymbols.clear();
 }
 
 } // namespace find_all_symbols
 } // namespace clang

include-fixer/find-all-symbols/FindAllSymbols.h

 ///
 /// NOTE:
 ///   - Symbols declared in main files are not collected since they can not be
 ///   included.
 ///   - Member functions are not collected because accessing them must go
 ///   through the class. #include fixer only needs the class name to find
 ///   headers.
 ///
-class FindAllSymbols : public clang::ast_matchers::MatchFinder::MatchCallback {
+class FindAllSymbols : public ast_matchers::MatchFinder::MatchCallback {
 public:
   explicit FindAllSymbols(SymbolReporter *Reporter,
                           HeaderMapCollector *Collector = nullptr)
       : Reporter(Reporter), Collector(Collector) {}
 
-  void registerMatchers(clang::ast_matchers::MatchFinder *MatchFinder);
+  void registerMatchers(ast_matchers::MatchFinder *MatchFinder);
 
-  void
-  run(const clang::ast_matchers::MatchFinder::MatchResult &result) override;
+  void run(const ast_matchers::MatchFinder::MatchResult &result) override;
+
+protected:
+  void onEndOfTranslationUnit() override;
 
 private:
+  // Current source file being processed, filled by first symbol found.
+  std::string Filename;
+  // Findings for the current source file, flushed on onEndOfTranslationUnit.
+  SymbolInfo::SignalMap FileSymbols;
   // Reporter for SymbolInfo.
   SymbolReporter *const Reporter;
   // A remapping header file collector allowing clients include a different
   // header.
   HeaderMapCollector *const Collector;
 };
 
 } // namespace find_all_symbols
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_FIND_ALL_SYMBOLS_SYMBOL_MATCHER_H

include-fixer/find-all-symbols/FindAllSymbols.cpp

void FindAllSymbols::registerMatchers(MatchFinder *MatchFinder) {
   // matcher since the declaration context is usually `MethodDecl`. However,
   // this assumption does not hold for parameters of a function pointer
   // parameter.
   // For example, consider a function declaration:
   //        void Func(void (*)(float), int);
   // The float parameter of the function pointer has an empty name, and its
   // declaration context is an anonymous namespace; therefore, it won't be
   // filtered out by our matchers above.
-  MatchFinder->addMatcher(varDecl(CommonFilter,
-                                  anyOf(ExternCMatcher, CCMatcher),
-                                  unless(parmVarDecl()))
-                              .bind("decl"),
-                          this);
+  auto Vars = varDecl(CommonFilter, anyOf(ExternCMatcher, CCMatcher),
+                      unless(parmVarDecl()));
 
   // Matchers for C-style record declarations in extern "C" {...}.
-  MatchFinder->addMatcher(
-      recordDecl(CommonFilter, ExternCMatcher, isDefinition()).bind("decl"),
-      this);
-
+  auto CRecords = recordDecl(CommonFilter, ExternCMatcher, isDefinition());
   // Matchers for C++ record declarations.
-  auto CxxRecordDecl =
-      cxxRecordDecl(CommonFilter, CCMatcher, isDefinition());
-  MatchFinder->addMatcher(CxxRecordDecl.bind("decl"), this);
+  auto CXXRecords = cxxRecordDecl(CommonFilter, CCMatcher, isDefinition());
 
   // Matchers for function declarations.
   // We want to exclude friend declaration, but the `DeclContext` of a friend
   // function declaration is not the class in which it is declared, so we need
   // to explicitly check if the parent is a `friendDecl`.
-  MatchFinder->addMatcher(functionDecl(CommonFilter,
-                                       unless(hasParent(friendDecl())),
-                                       anyOf(ExternCMatcher, CCMatcher))
-                              .bind("decl"),
-                          this);
+  auto Functions = functionDecl(CommonFilter, unless(hasParent(friendDecl())),
+                                anyOf(ExternCMatcher, CCMatcher));
 
   // Matcher for typedef and type alias declarations.
   //
-  // typedef and type alias can come from C-style headers and C++ heaeders.
-  // For C-style header, `DeclContxet` can be either `TranslationUnitDecl`
+  // typedef and type alias can come from C-style headers and C++ headers.
+  // For C-style headers, `DeclContxet` can be either `TranslationUnitDecl`
   // or `LinkageSpecDecl`.
-  // For C++ header, `DeclContext ` can be one of `TranslationUnitDecl`,
-  // `NamespaceDecl`.
+  // For C++ headers, `DeclContext ` can be either `TranslationUnitDecl`
+  // or `NamespaceDecl`.
   // With the following context matcher, we can match `typedefNameDecl` from
-  // both C-style header and C++ header (except for those in classes).
+  // both C-style headers and C++ headers (except for those in classes).
   // "cc_matchers" are not included since template-related matchers are not
   // applicable on `TypedefNameDecl`.
-  MatchFinder->addMatcher(
+  auto Typedefs =
       typedefNameDecl(CommonFilter, anyOf(HasNSOrTUCtxMatcher,
-                                          hasDeclContext(linkageSpecDecl())))
-          .bind("decl"),
-      this);
+                                          hasDeclContext(linkageSpecDecl())));
 
   // Matchers for enum declarations.
-  MatchFinder->addMatcher(enumDecl(CommonFilter, isDefinition(),
-                                   anyOf(HasNSOrTUCtxMatcher, ExternCMatcher))
-                              .bind("decl"),
-                          this);
+  auto Enums = enumDecl(CommonFilter, isDefinition(),
+                        anyOf(HasNSOrTUCtxMatcher, ExternCMatcher));
 
   // Matchers for enum constant declarations.
   // We only match the enum constants in non-scoped enum declarations which are
   // inside toplevel translation unit or a namespace.
+  auto EnumConstants = enumConstantDecl(
+      CommonFilter, unless(isInScopedEnum()),
+      anyOf(hasDeclContext(enumDecl(HasNSOrTUCtxMatcher)), ExternCMatcher));
+
+  // Most of the time we care about all matchable decls, or all types.
+  auto Types = namedDecl(anyOf(CRecords, CXXRecords, Enums, Typedefs));
+  auto Decls = namedDecl(anyOf(CRecords, CXXRecords, Enums, Typedefs, Vars,
+                               EnumConstants, Functions));
+
+  // We want eligible decls bound to "decl"...
+  MatchFinder->addMatcher(Decls.bind("decl"), this);
+
+  // ... and all uses of them bound to "use". These have many cases:
+  // Uses of values/functions: these generate a declRefExpr.
+  MatchFinder->addMatcher(
+      declRefExpr(isExpansionInMainFile(), to(Decls.bind("use"))), this);
+  // Uses of function templates:
   MatchFinder->addMatcher(
-      enumConstantDecl(
-          CommonFilter,
-          unless(isInScopedEnum()),
-          anyOf(hasDeclContext(enumDecl(HasNSOrTUCtxMatcher)), ExternCMatcher))
-          .bind("decl"),
+      declRefExpr(isExpansionInMainFile(),
+                  to(functionDecl(hasParent(
+                      functionTemplateDecl(has(Functions.bind("use"))))))),
+      this);
+
+  // Uses of most types: just look at what the typeLoc refers to.
+  MatchFinder->addMatcher(
+      typeLoc(isExpansionInMainFile(),
+              loc(qualType(hasDeclaration(Types.bind("use"))))),
+      this);
+  // Uses of typedefs: these are transparent to hasDeclaration, so we need to
+  // handle them explicitly.
+  MatchFinder->addMatcher(
+      typeLoc(isExpansionInMainFile(),
+              loc(typedefType(hasDeclaration(Typedefs.bind("use"))))),
+      this);
+  // Uses of class templates:
+  // The typeLoc names the templateSpecializationType. Its declaration is the
+  // ClassTemplateDecl, which contains the CXXRecordDecl we want.
+  MatchFinder->addMatcher(
+      typeLoc(isExpansionInMainFile(),
+              loc(templateSpecializationType(hasDeclaration(
+                  classTemplateDecl(has(CXXRecords.bind("use"))))))),
       this);
 }
 
 void FindAllSymbols::run(const MatchFinder::MatchResult &Result) {
   // Ignore Results in failing TUs.
   if (Result.Context->getDiagnostics().hasErrorOccurred()) {
     return;
   }
 
-  const auto *ND = Result.Nodes.getNodeAs<NamedDecl>("decl");
-  assert(ND && "Matched declaration must be a NamedDecl!");
+  SymbolInfo::Signals Signals;
+  const NamedDecl *ND;
+  if ((ND = Result.Nodes.getNodeAs<NamedDecl>("use")))
+    Signals.Used = 1;
+  else if ((ND = Result.Nodes.getNodeAs<NamedDecl>("decl")))
+    Signals.Seen = 1;
+  else
+    assert(false && "Must match a NamedDecl!");
+
   const SourceManager *SM = Result.SourceManager;
+  if (auto Symbol = CreateSymbolInfo(ND, *SM, Collector)) {
+    Filename = SM->getFileEntryForID(SM->getMainFileID())->getName();
+    FileSymbols[*Symbol] += Signals;
+  }
+}
 
-  llvm::Optional<SymbolInfo> Symbol =
-      CreateSymbolInfo(ND, *SM, Collector);
-  if (Symbol)
-    Reporter->reportSymbol(
-        SM->getFileEntryForID(SM->getMainFileID())->getName(), *Symbol);
+void FindAllSymbols::onEndOfTranslationUnit() {
+  if (Filename != "") {
+    Reporter->reportSymbols(Filename, FileSymbols);
+    FileSymbols.clear();
+    Filename = "";
+  }
 }
 
 } // namespace find_all_symbols
 } // namespace clang

include-fixer/find-all-symbols/FindAllSymbolsAction.cpp

 FindAllSymbolsAction::FindAllSymbolsAction(
     SymbolReporter *Reporter,
     const HeaderMapCollector::RegexHeaderMap *RegexHeaderMap)
     : Reporter(Reporter), Collector(RegexHeaderMap), Handler(&Collector),
       Matcher(Reporter, &Collector) {
   Matcher.registerMatchers(&MatchFinder);
 }
 
-std::unique_ptr<clang::ASTConsumer>
-FindAllSymbolsAction::CreateASTConsumer(clang::CompilerInstance &Compiler,
+std::unique_ptr<ASTConsumer>
+FindAllSymbolsAction::CreateASTConsumer(CompilerInstance &Compiler,
                                         StringRef InFile) {
   Compiler.getPreprocessor().addCommentHandler(&Handler);
   Compiler.getPreprocessor().addPPCallbacks(llvm::make_unique<FindAllMacros>(
       Reporter, &Compiler.getSourceManager(), &Collector));
   return MatchFinder.newASTConsumer();
 }
 
 } // namespace find_all_symbols
 } // namespace clang

include-fixer/find-all-symbols/SymbolInfo.h

 #include "llvm/Support/YAMLTraits.h"
 #include "llvm/Support/raw_ostream.h"
 #include <set>
 #include <string>
 #include <vector>
 
 namespace clang {
 namespace find_all_symbols {
-
 /// \brief Contains all information for a Symbol.
 class SymbolInfo {
 public:
   /// \brief The SymbolInfo Type.
   enum class SymbolKind {
     Function,
     Class,
     Variable,
enum class ContextType {
     Namespace, // Symbols declared in a namespace.
     Record,    // Symbols declared in a class.
     EnumDecl,  // Enum constants declared in a enum declaration.
   };
 
   /// \brief A pair of <ContextType, ContextName>.
   typedef std::pair<ContextType, std::string> Context;
 
+  // \brief Signals are signals gathered by observing how a symbol is used.
+  // These are used to rank results.
+  struct Signals {
+    Signals() {}
+    Signals(unsigned Seen, unsigned Used) : Seen(Seen), Used(Used) {}
+
+    // Number of times this symbol was visible to a TU.
+    unsigned Seen = 0;
+
+    // Number of times this symbol was referenced a TU's main file.
+    unsigned Used = 0;
+
+    Signals &operator+=(const Signals &RHS);
+    Signals operator+(const Signals &RHS) const;
+  };
+
+  using SignalMap = std::map<SymbolInfo, Signals>;
+
   // The default constructor is required by YAML traits in
   // LLVM_YAML_IS_DOCUMENT_LIST_VECTOR.
   SymbolInfo() : Type(SymbolKind::Unknown), LineNumber(-1) {}
 
   SymbolInfo(llvm::StringRef Name, SymbolKind Type, llvm::StringRef FilePath,
-             int LineNumber, const std::vector<Context> &Contexts,
-             unsigned NumOccurrences = 0);
+             int LineNumber, const std::vector<Context> &Contexts);
 
   void SetFilePath(llvm::StringRef Path) { FilePath = Path; }
 
   /// \brief Get symbol name.
   llvm::StringRef getName() const { return Name; }
 
   /// \brief Get the fully-qualified symbol name.
   std::string getQualifiedName() const;
 
   /// \brief Get symbol type.
   SymbolKind getSymbolKind() const { return Type; }
 
   /// \brief Get a relative file path where symbol comes from.
   llvm::StringRef getFilePath() const { return FilePath; }
 
   /// \brief Get symbol contexts.
   const std::vector<SymbolInfo::Context> &getContexts() const {
     return Contexts;
   }
 
   /// \brief Get a 1-based line number of the symbol's declaration.
   int getLineNumber() const { return LineNumber; }
 
-  /// \brief The number of times this symbol was found during an indexing run.
-  unsigned getNumOccurrences() const { return NumOccurrences; }
-
   bool operator<(const SymbolInfo &Symbol) const;
 
   bool operator==(const SymbolInfo &Symbol) const;
 
 private:
-  friend struct llvm::yaml::MappingTraits<SymbolInfo>;
+  friend struct llvm::yaml::MappingTraits<struct SymbolAndSignals>;
 
   /// \brief Identifier name.
   std::string Name;
 
   /// \brief Symbol type.
   SymbolKind Type;
 
   /// \brief The file path where the symbol comes from. It's a relative file
private:
   /// "na"} }.
   /// The name of an anonymous namespace is "".
   ///
   /// If the symbol is declared in `TranslationUnitDecl`, it has no context.
   std::vector<Context> Contexts;
 
   /// \brief The 1-based line number of of the symbol's declaration.
   int LineNumber;
+};
 
-  /// \brief The number of times this symbol was found during an indexing
-  /// run. Populated by the reducer and used to rank results.
-  unsigned NumOccurrences;
+struct SymbolAndSignals {
+  SymbolInfo Symbol;
+  SymbolInfo::Signals Signals;
 };
 
 /// \brief Write SymbolInfos to a stream (YAML format).
 bool WriteSymbolInfosToStream(llvm::raw_ostream &OS,
-                              const std::set<SymbolInfo> &Symbols);
+                              const SymbolInfo::SignalMap &Symbols);
 
 /// \brief Read SymbolInfos from a YAML document.
-std::vector<SymbolInfo> ReadSymbolInfosFromYAML(llvm::StringRef Yaml);
+std::vector<SymbolAndSignals> ReadSymbolInfosFromYAML(llvm::StringRef Yaml);
 
 } // namespace find_all_symbols
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_INCLUDE_FIXER_FIND_ALL_SYMBOLS_SYMBOLINFO_H

include-fixer/find-all-symbols/SymbolInfo.cpp

 #include "llvm/Support/YAMLTraits.h"
 #include "llvm/Support/raw_ostream.h"
 
 using llvm::yaml::MappingTraits;
 using llvm::yaml::IO;
 using llvm::yaml::Input;
 using ContextType = clang::find_all_symbols::SymbolInfo::ContextType;
 using clang::find_all_symbols::SymbolInfo;
+using clang::find_all_symbols::SymbolAndSignals;
 using SymbolKind = clang::find_all_symbols::SymbolInfo::SymbolKind;
 
-LLVM_YAML_IS_DOCUMENT_LIST_VECTOR(SymbolInfo)
+LLVM_YAML_IS_DOCUMENT_LIST_VECTOR(SymbolAndSignals)
 LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(std::string)
 LLVM_YAML_IS_SEQUENCE_VECTOR(SymbolInfo::Context)
 
 namespace llvm {
 namespace yaml {
-template <> struct MappingTraits<SymbolInfo> {
-  static void mapping(IO &io, SymbolInfo &Symbol) {
-    io.mapRequired("Name", Symbol.Name);
-    io.mapRequired("Contexts", Symbol.Contexts);
-    io.mapRequired("FilePath", Symbol.FilePath);
-    io.mapRequired("LineNumber", Symbol.LineNumber);
-    io.mapRequired("Type", Symbol.Type);
-    io.mapRequired("NumOccurrences", Symbol.NumOccurrences);
+template <> struct MappingTraits<SymbolAndSignals> {
+  static void mapping(IO &io, SymbolAndSignals &Symbol) {
+    io.mapRequired("Name", Symbol.Symbol.Name);
+    io.mapRequired("Contexts", Symbol.Symbol.Contexts);
+    io.mapRequired("FilePath", Symbol.Symbol.FilePath);
+    io.mapRequired("LineNumber", Symbol.Symbol.LineNumber);
+    io.mapRequired("Type", Symbol.Symbol.Type);
+    io.mapRequired("Seen", Symbol.Signals.Seen);
+    io.mapRequired("Used", Symbol.Signals.Used);
   }
 };
 
 template <> struct ScalarEnumerationTraits<ContextType> {
   static void enumeration(IO &io, ContextType &value) {
     io.enumCase(value, "Record", ContextType::Record);
     io.enumCase(value, "Namespace", ContextType::Namespace);
     io.enumCase(value, "EnumDecl", ContextType::EnumDecl);

 } // namespace yaml
 } // namespace llvm
 
 namespace clang {
 namespace find_all_symbols {
 
 SymbolInfo::SymbolInfo(llvm::StringRef Name, SymbolKind Type,
                        llvm::StringRef FilePath, int LineNumber,
-                       const std::vector<Context> &Contexts,
-                       unsigned NumOccurrences)
+                       const std::vector<Context> &Contexts)
     : Name(Name), Type(Type), FilePath(FilePath), Contexts(Contexts),
-      LineNumber(LineNumber), NumOccurrences(NumOccurrences) {}
+      LineNumber(LineNumber) {}
 
 bool SymbolInfo::operator==(const SymbolInfo &Symbol) const {
   return std::tie(Name, Type, FilePath, LineNumber, Contexts) ==
          std::tie(Symbol.Name, Symbol.Type, Symbol.FilePath, Symbol.LineNumber,
                   Symbol.Contexts);
 }
 
 bool SymbolInfo::operator<(const SymbolInfo &Symbol) const {
   return std::tie(Name, Type, FilePath, LineNumber, Contexts) <
          std::tie(Symbol.Name, Symbol.Type, Symbol.FilePath, Symbol.LineNumber,
                   Symbol.Contexts);
 }
 
 std::string SymbolInfo::getQualifiedName() const {
   std::string QualifiedName = Name;
   for (const auto &Context : Contexts) {
     if (Context.first == ContextType::EnumDecl)
       continue;
     QualifiedName = Context.second + "::" + QualifiedName;
   }
   return QualifiedName;
 }
 
+SymbolInfo::Signals &SymbolInfo::Signals::operator+=(const Signals &RHS) {
+  Seen += RHS.Seen;
+  Used += RHS.Used;
+  return *this;
+}
+
+SymbolInfo::Signals SymbolInfo::Signals::operator+(const Signals &RHS) const {
+  Signals Result = *this;
+  Result += RHS;
+  return Result;
+}
+
 bool WriteSymbolInfosToStream(llvm::raw_ostream &OS,
-                              const std::set<SymbolInfo> &Symbols) {
+                              const SymbolInfo::SignalMap &Symbols) {
   llvm::yaml::Output yout(OS);
-  for (auto Symbol : Symbols)
-    yout << Symbol;
+  for (const auto &Symbol : Symbols) {
+    SymbolAndSignals S{Symbol.first, Symbol.second};
+    yout << S;
+  }
   return true;
 }
 
-std::vector<SymbolInfo> ReadSymbolInfosFromYAML(llvm::StringRef Yaml) {
-  std::vector<SymbolInfo> Symbols;
+std::vector<SymbolAndSignals> ReadSymbolInfosFromYAML(llvm::StringRef Yaml) {
+  std::vector<SymbolAndSignals> Symbols;
   llvm::yaml::Input yin(Yaml);
   yin >> Symbols;
   return Symbols;
 }
 
 } // namespace find_all_symbols
 } // namespace clang

include-fixer/find-all-symbols/SymbolReporter.h

 namespace clang {
 namespace find_all_symbols {
 
 /// \brief An interface for classes that collect symbols.
 class SymbolReporter {
 public:
   virtual ~SymbolReporter() = default;
 
-  virtual void reportSymbol(llvm::StringRef FileName,
-                            const SymbolInfo &Symbol) = 0;
+  virtual void reportSymbols(llvm::StringRef FileName,
+                             const SymbolInfo::SignalMap &Symbols) = 0;
 };
 
 } // namespace find_all_symbols
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_FIND_ALL_SYMBOLS_SYMBOL_REPORTER_H

include-fixer/find-all-symbols/tool/FindAllSymbolsMain.cpp

 
 static cl::opt<std::string> MergeDir("merge-dir", cl::desc(R"(
 The directory for merging symbols.)"),
                                      cl::init(""),
                                      cl::cat(FindAllSymbolsCategory));
 namespace clang {
 namespace find_all_symbols {
 
-class YamlReporter : public clang::find_all_symbols::SymbolReporter {
+class YamlReporter : public SymbolReporter {
 public:
-  ~YamlReporter() override {
-    for (const auto &Symbol : Symbols) {
-      int FD;
-      SmallString<128> ResultPath;
-      llvm::sys::fs::createUniqueFile(
-          OutputDir + "/" + llvm::sys::path::filename(Symbol.first) +
-              "-%%%%%%.yaml",
-          FD, ResultPath);
-      llvm::raw_fd_ostream OS(FD, /*shouldClose=*/true);
-      WriteSymbolInfosToStream(OS, Symbol.second);
-    }
-  }
-
-  void reportSymbol(StringRef FileName, const SymbolInfo &Symbol) override {
-    Symbols[FileName].insert(Symbol);
-  }
-
-private:
-  std::map<std::string, std::set<SymbolInfo>> Symbols;
+  void reportSymbols(StringRef FileName,
+                     const SymbolInfo::SignalMap &Symbols) override {
+        OutputDir + "/" + llvm::sys::path::filename(FileName) + "-%%%%%%.yaml",
+    WriteSymbolInfosToStream(OS, Symbols);
 };
 
 bool Merge(llvm::StringRef MergeDir, llvm::StringRef OutputFile) {
   std::error_code EC;
-  std::map<SymbolInfo, int> SymbolToNumOccurrences;
+  SymbolInfo::SignalMap Symbols;
   std::mutex SymbolMutex;
-  auto AddSymbols = [&](ArrayRef<SymbolInfo> Symbols) {
+  auto AddSymbols = [&](ArrayRef<SymbolAndSignals> NewSymbols) {
     // Synchronize set accesses.
     std::unique_lock<std::mutex> LockGuard(SymbolMutex);
-    for (const auto &Symbol : Symbols)
-      ++SymbolToNumOccurrences[Symbol];
+    for (const auto &Symbol : NewSymbols) {
+      Symbols[Symbol.Symbol] += Symbol.Signals;
+    }
   };
 
   // Load all symbol files in MergeDir.
   {
     llvm::ThreadPool Pool;
     for (llvm::sys::fs::directory_iterator Dir(MergeDir, EC), DirEnd;
          Dir != DirEnd && !EC; Dir.increment(EC)) {
       // Parse YAML files in parallel.
       Pool.async(
           [&AddSymbols](std::string Path) {
             auto Buffer = llvm::MemoryBuffer::getFile(Path);
             if (!Buffer) {
               llvm::errs() << "Can't open " << Path << "\n";
               return;
             }
-            std::vector<SymbolInfo> Symbols =
+            std::vector<SymbolAndSignals> Symbols =
                 ReadSymbolInfosFromYAML(Buffer.get()->getBuffer());
+            for (auto &Symbol : Symbols) {
+              // Only count one occurrence per file, to avoid spam.
+              Symbol.Signals.Seen = std::min(Symbol.Signals.Seen, 1u);
+              Symbol.Signals.Used = std::min(Symbol.Signals.Used, 1u);
+            }
             // FIXME: Merge without creating such a heavy contention point.
             AddSymbols(Symbols);
           },
           Dir->path());
     }
   }
 
   llvm::raw_fd_ostream OS(OutputFile, EC, llvm::sys::fs::F_None);
   if (EC) {
     llvm::errs() << "Can't open '" << OutputFile << "': " << EC.message()
                  << '\n';
     return false;
   }
-  std::set<SymbolInfo> Result;
-  for (const auto &Entry : SymbolToNumOccurrences) {
-    const auto &Symbol = Entry.first;
-    Result.insert(SymbolInfo(Symbol.getName(), Symbol.getSymbolKind(),
-                             Symbol.getFilePath(), Symbol.getLineNumber(),
-                             Symbol.getContexts(), Entry.second));
-  }
-  WriteSymbolInfosToStream(OS, Result);
+  WriteSymbolInfosToStream(OS, Symbols);
   return true;
 }
 
 } // namespace clang
 } // namespace find_all_symbols
 
 int main(int argc, const char **argv) {
   CommonOptionsParser OptionsParser(argc, argv, FindAllSymbolsCategory);

include-fixer/tool/ClangIncludeFixer.cpp

 cl::opt<std::string>
     Style("style",
           cl::desc("Fallback style for reformatting after inserting new\n"
                    "headers if there is no clang-format config file found."),
           cl::init("llvm"), cl::cat(IncludeFixerCategory));
 
 std::unique_ptr<include_fixer::SymbolIndexManager>
 createSymbolIndexManager(StringRef FilePath) {
+  using find_all_symbols::SymbolInfo;
+
   auto SymbolIndexMgr = llvm::make_unique<include_fixer::SymbolIndexManager>();
   switch (DatabaseFormat) {
   case fixed: {
     // Parse input and fill the database with it.
     // <symbol>=<header><, header...>
     // Multiple symbols can be given, separated by semicolons.
     std::map<std::string, std::vector<std::string>> SymbolsMap;
     SmallVector<StringRef, 4> SemicolonSplits;
     StringRef(Input).split(SemicolonSplits, ";");
-    std::vector<find_all_symbols::SymbolInfo> Symbols;
+    std::vector<find_all_symbols::SymbolAndSignals> Symbols;
     for (StringRef Pair : SemicolonSplits) {
       auto Split = Pair.split('=');
       std::vector<std::string> Headers;
       SmallVector<StringRef, 4> CommaSplits;
       Split.second.split(CommaSplits, ",");
       for (size_t I = 0, E = CommaSplits.size(); I != E; ++I)
-        Symbols.push_back(find_all_symbols::SymbolInfo(
-            Split.first.trim(),
-            find_all_symbols::SymbolInfo::SymbolKind::Unknown,
-            CommaSplits[I].trim(), 1, {}, /*NumOccurrences=*/E - I));
+        Symbols.push_back(
+            {SymbolInfo(Split.first.trim(), SymbolInfo::SymbolKind::Unknown,
+                        CommaSplits[I].trim(), 1, {}),
+             // Use fake "seen" signal for tests, so first header wins.
+             SymbolInfo::Signals(/*Seen=*/static_cast<unsigned>(E - I),
+                                 /*Used=*/0)});
     }
     SymbolIndexMgr->addSymbolIndex([=]() {
       return llvm::make_unique<include_fixer::InMemorySymbolIndex>(Symbols);
     });
     break;
   }
   case yaml: {
     auto CreateYamlIdx = [=]() -> std::unique_ptr<include_fixer::SymbolIndex> {

test/include-fixer/Inputs/fake_yaml_db.yaml

 ---
 Name:           foo
 Contexts:
   - ContextType:     Namespace
     ContextName:     a
   - ContextType:     Namespace
     ContextName:     b
 FilePath:        foo.h
 LineNumber:      1
 Type:            Class
-NumOccurrences:  1
+Seen:            1
+Used:            0
 ---
 Name:           bar
 Contexts:
   - ContextType:     Namespace
     ContextName:     a
   - ContextType:     Namespace
     ContextName:     b
 FilePath:        ../include/bar.h
 LineNumber:      1
 Type:            Class
-NumOccurrences:  1
+Seen:            1
+Used:            0
 ---
 Name:           bar
 Contexts:
   - ContextType:     Namespace
     ContextName:     a
   - ContextType:     Namespace
     ContextName:     b
 FilePath:        ../include/bar.h
 LineNumber:      2
 Type:            Class
-NumOccurrences:  3
+Seen:            3
+Used:            0
 ---
 Name:           bar
 Contexts:
   - ContextType:     Namespace
     ContextName:     a
   - ContextType:     Namespace
     ContextName:     b
 FilePath:        ../include/zbar.h
 LineNumber:      1
 Type:            Class
-NumOccurrences:  3
+Seen:            3
+Used:            0
 ---
 Name:           b
 Contexts:
 FilePath:        var.h
 LineNumber:      1
 Type:            Variable
-NumOccurrences:  1
+Seen:            1
+Used:            0
 ---
 Name:            bar
 Contexts:
   - ContextType:    Namespace
     ContextName:    c
 FilePath:        test/include-fixer/baz.h
 LineNumber:      1
 Type:            Class
-NumOccurrences:  1
+Seen:            1
+Used:            0

test/include-fixer/Inputs/merge/a.yaml

 ---
 Name:           foo
 Contexts:
   - ContextType:     Namespace
     ContextName:     a
 FilePath:        foo.h
 LineNumber:      1
 Type:            Class
-NumOccurrences:  1
+Seen:            1
+Used:            1
 ...
 ---
 Name:           bar
 Contexts:
   - ContextType:     Namespace
     ContextName:     a
 FilePath:        ../include/bar.h
 LineNumber:      1
 Type:            Class
-NumOccurrences:  1
+Seen:            1
+Used:            2
 ...

test/include-fixer/Inputs/merge/b.yaml

 ---
 Name:           foo
 Contexts:
   - ContextType:     Namespace
     ContextName:     a
 FilePath:        foo.h
 LineNumber:      1
 Type:            Class
-NumOccurrences:  1
+Seen:            1
+Used:            2
 ...
 ---
 Name:           bar
 Contexts:
   - ContextType:     Namespace
     ContextName:     a
 FilePath:        ../include/barbar.h
 LineNumber:      1
 Type:            Class
-NumOccurrences:  1
+Seen:            1
+Used:            0
 ...

test/include-fixer/merge.test

 # RUN: find-all-symbols -merge-dir=%S/Inputs/merge %t.merged
 # RUN: sed '/^#/d' %s > %t.golden
 # RUN: diff -u %t.golden %t.merged
 ---
 Name:            bar
 Contexts:        
   - ContextType:     Namespace
     ContextName:     a
 FilePath:        ../include/bar.h
 LineNumber:      1
 Type:            Class
-NumOccurrences:  1
+Seen:            1
+Used:            1
 ...
 ---
 Name:            bar
 Contexts:        
   - ContextType:     Namespace
     ContextName:     a
 FilePath:        ../include/barbar.h
 LineNumber:      1
 Type:            Class
-NumOccurrences:  1
+Seen:            1
+Used:            0
 ...
 ---
 Name:            foo
 Contexts:        
   - ContextType:     Namespace
     ContextName:     a
 FilePath:        foo.h
 LineNumber:      1
 Type:            Class
-NumOccurrences:  2
+Seen:            2
+Used:            2
 ...

unittests/include-fixer/IncludeFixerTest.cpp

 #include "clang/Tooling/Tooling.h"
 #include "gtest/gtest.h"
 
 namespace clang {
 namespace include_fixer {
 namespace {
 
 using find_all_symbols::SymbolInfo;
+using find_all_symbols::SymbolAndSignals;
 
 static bool runOnCode(tooling::ToolAction *ToolAction, StringRef Code,
                       StringRef FileName,
                       const std::vector<std::string> &ExtraArgs) {
   llvm::IntrusiveRefCntPtr<vfs::InMemoryFileSystem> InMemoryFileSystem(
       new vfs::InMemoryFileSystem);
   llvm::IntrusiveRefCntPtr<FileManager> Files(
       new FileManager(FileSystemOptions(), InMemoryFileSystem));
static bool runOnCode(tooling::ToolAction *ToolAction, StringRef Code,
   InMemoryFileSystem->addFile("header.h", 0,
                               llvm::MemoryBuffer::getMemBuffer("bar b;"));
   return Invocation.run();
 }
 
 static std::string runIncludeFixer(
     StringRef Code,
     const std::vector<std::string> &ExtraArgs = std::vector<std::string>()) {
-  std::vector<SymbolInfo> Symbols = {
-      SymbolInfo("string", SymbolInfo::SymbolKind::Class, "<string>", 1,
+  std::vector<SymbolAndSignals> Symbols = {
+      {SymbolInfo("string", SymbolInfo::SymbolKind::Class, "<string>", 1,
                   {{SymbolInfo::ContextType::Namespace, "std"}}),
-      SymbolInfo("sting", SymbolInfo::SymbolKind::Class, "\"sting\"", 1,
+       SymbolInfo::Signals{}},
+      {SymbolInfo("sting", SymbolInfo::SymbolKind::Class, "\"sting\"", 1,
                   {{SymbolInfo::ContextType::Namespace, "std"}}),
-      SymbolInfo("foo", SymbolInfo::SymbolKind::Class, "\"dir/otherdir/qux.h\"",
-                 1, {{SymbolInfo::ContextType::Namespace, "b"},
-                     {SymbolInfo::ContextType::Namespace, "a"}}),
-      SymbolInfo("bar", SymbolInfo::SymbolKind::Class, "\"bar.h\"", 1,
+       SymbolInfo::Signals{}},
+      {SymbolInfo("foo", SymbolInfo::SymbolKind::Class,
+                  "\"dir/otherdir/qux.h\"", 1,
+                  {{SymbolInfo::ContextType::Namespace, "b"},
+       SymbolInfo::Signals{}},
+      {SymbolInfo("bar", SymbolInfo::SymbolKind::Class, "\"bar.h\"", 1,
                   {{SymbolInfo::ContextType::Namespace, "b"},
                    {SymbolInfo::ContextType::Namespace, "a"}}),
-      SymbolInfo("bar", SymbolInfo::SymbolKind::Class, "\"bar2.h\"", 1,
+       SymbolInfo::Signals{}},
+      {SymbolInfo("bar", SymbolInfo::SymbolKind::Class, "\"bar2.h\"", 1,
                   {{SymbolInfo::ContextType::Namespace, "c"},
                    {SymbolInfo::ContextType::Namespace, "a"}}),
-      SymbolInfo("Green", SymbolInfo::SymbolKind::Class, "\"color.h\"", 1,
+       SymbolInfo::Signals{}},
+      {SymbolInfo("Green", SymbolInfo::SymbolKind::Class, "\"color.h\"", 1,
                   {{SymbolInfo::ContextType::EnumDecl, "Color"},
                    {SymbolInfo::ContextType::Namespace, "b"},
                    {SymbolInfo::ContextType::Namespace, "a"}}),
-      SymbolInfo("Vector", SymbolInfo::SymbolKind::Class, "\"Vector.h\"", 1,
+       SymbolInfo::Signals{}},
+      {SymbolInfo("Vector", SymbolInfo::SymbolKind::Class, "\"Vector.h\"", 1,
                   {{SymbolInfo::ContextType::Namespace, "__a"},
-                  {SymbolInfo::ContextType::Namespace, "a"}},
-                 /*num_occurrences=*/2),
-      SymbolInfo("Vector", SymbolInfo::SymbolKind::Class, "\"Vector.h\"", 2,
-                 {{SymbolInfo::ContextType::Namespace, "a"}},
-                 /*num_occurrences=*/1),
-      SymbolInfo("StrCat", SymbolInfo::SymbolKind::Class, "\"strcat.h\"",
-                 1, {{SymbolInfo::ContextType::Namespace, "str"}}),
-      SymbolInfo("str", SymbolInfo::SymbolKind::Class, "\"str.h\"",
-                 1, {}),
-      SymbolInfo("foo2", SymbolInfo::SymbolKind::Class, "\"foo2.h\"",
-                 1, {}),
+                   {SymbolInfo::ContextType::Namespace, "a"}}),
+       SymbolInfo::Signals{/*Seen=*/2, 0}},
+      {SymbolInfo("Vector", SymbolInfo::SymbolKind::Class, "\"Vector.h\"", 2,
+                  {{SymbolInfo::ContextType::Namespace, "a"}}),
+       SymbolInfo::Signals{/*Seen=*/2, 0}},
+      {SymbolInfo("StrCat", SymbolInfo::SymbolKind::Class, "\"strcat.h\"", 1,
+                  {{SymbolInfo::ContextType::Namespace, "str"}}),
+       SymbolInfo::Signals{}},
+      {SymbolInfo("str", SymbolInfo::SymbolKind::Class, "\"str.h\"", 1, {}),
+       SymbolInfo::Signals{}},
+      {SymbolInfo("foo2", SymbolInfo::SymbolKind::Class, "\"foo2.h\"", 1, {}),
+       SymbolInfo::Signals{}},
   };
-  auto SymbolIndexMgr = llvm::make_unique<include_fixer::SymbolIndexManager>();
-  SymbolIndexMgr->addSymbolIndex([=]() {
-    return llvm::make_unique<include_fixer::InMemorySymbolIndex>(Symbols);
-  });
+  auto SymbolIndexMgr = llvm::make_unique<SymbolIndexManager>();
+  SymbolIndexMgr->addSymbolIndex(
+      [=]() { return llvm::make_unique<InMemorySymbolIndex>(Symbols); });
 
   std::vector<IncludeFixerContext> FixerContexts;
   IncludeFixerActionFactory Factory(*SymbolIndexMgr, FixerContexts, "llvm");
   std::string FakeFileName = "input.cc";
   runOnCode(&Factory, Code, FakeFileName, ExtraArgs);
   assert(FixerContexts.size() == 1);
   if (FixerContexts.front().getHeaderInfos().empty())
     return Code;
-  auto Replaces = clang::include_fixer::createIncludeFixerReplacements(
-      Code, FixerContexts.front());
+  auto Replaces = createIncludeFixerReplacements(Code, FixerContexts.front());
   EXPECT_TRUE(static_cast<bool>(Replaces))
       << llvm::toString(Replaces.takeError()) << "\n";
   if (!Replaces)
     return "";
-  clang::RewriterTestContext Context;
-  clang::FileID ID = Context.createInMemoryFile(FakeFileName, Code);
-  clang::tooling::applyAllReplacements(*Replaces, Context.Rewrite);
+  RewriterTestContext Context;
+  FileID ID = Context.createInMemoryFile(FakeFileName, Code);
+  tooling::applyAllReplacements(*Replaces, Context.Rewrite);
   return Context.getRewrittenText(ID);
 }
 
 TEST(IncludeFixer, Typo) {
   EXPECT_EQ("#include <string>\nstd::string foo;\n",
             runIncludeFixer("std::string foo;\n"));
 
   EXPECT_EQ("// comment\n#include \"foo.h\"\n#include <string>\n"

unittests/include-fixer/find-all-symbols/FindAllSymbolsTests.cpp

 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/FileSystemOptions.h"
 #include "clang/Basic/VirtualFileSystem.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/PCHContainerOperations.h"
 #include "clang/Tooling/Tooling.h"
 #include "llvm/ADT/IntrusiveRefCntPtr.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "gtest/gtest.h"
 #include <memory>
 #include <string>
 #include <vector>
 
 namespace clang {
 namespace find_all_symbols {
 
 static const char HeaderName[] = "symbols.h";
 
-class TestSymbolReporter : public clang::find_all_symbols::SymbolReporter {
+class TestSymbolReporter : public SymbolReporter {
 public:
   ~TestSymbolReporter() override {}
 
-  void reportSymbol(llvm::StringRef FileName,
-                    const SymbolInfo &Symbol) override {
-    Symbols.push_back(Symbol);
+  void reportSymbols(llvm::StringRef FileName,
+                     const SymbolInfo::SignalMap &NewSymbols) override {
+    for (const auto &Entry : NewSymbols)
+      Symbols[Entry.first] += Entry.second;
   }
 
   bool hasSymbol(const SymbolInfo &Symbol) const {
-    for (const auto &S : Symbols) {
-      if (S == Symbol)
-        return true;
-    }
-    return false;
+    auto it = Symbols.find(Symbol);
+    return it != Symbols.end() && it->second.Seen > 0;
+
+  bool hasUse(const SymbolInfo &Symbol) const {
+    auto it = Symbols.find(Symbol);
+    return it != Symbols.end() && it->second.Used > 0;
   }
 
 private:
-  std::vector<SymbolInfo> Symbols;
+  SymbolInfo::SignalMap Symbols;
 };
 
 class FindAllSymbolsTest : public ::testing::Test {
 public:
   bool hasSymbol(const SymbolInfo &Symbol) {
     return Reporter.hasSymbol(Symbol);
   }
 
-  bool runFindAllSymbols(StringRef Code) {
+  bool hasUse(const SymbolInfo &Symbol) { return Reporter.hasUse(Symbol); }
+
+  bool runFindAllSymbols(StringRef HeaderCode, StringRef MainCode) {
     llvm::IntrusiveRefCntPtr<vfs::InMemoryFileSystem> InMemoryFileSystem(
         new vfs::InMemoryFileSystem);
     llvm::IntrusiveRefCntPtr<FileManager> Files(
         new FileManager(FileSystemOptions(), InMemoryFileSystem));
 
     std::string FileName = "symbol.cc";
 
     const std::string InternalHeader = "internal/internal_header.h";
SymbolInfo InternalSymbol("Internal", SymbolInfo::SymbolKind::Class,
                               TopHeader, 2, {});
     SymbolInfo IncSymbol("IncHeaderClass", SymbolInfo::SymbolKind::Class,
                          TopHeader, 1, {});
     InMemoryFileSystem->addFile(
         IncHeader, 0, llvm::MemoryBuffer::getMemBuffer(IncHeaderCode));
     InMemoryFileSystem->addFile(InternalHeader, 0,
                                 llvm::MemoryBuffer::getMemBuffer(InternalCode));
 
-    std::unique_ptr<clang::tooling::FrontendActionFactory> Factory(
+    std::unique_ptr<tooling::FrontendActionFactory> Factory(
         new FindAllSymbolsActionFactory(&Reporter, &RegexMap));
 
     tooling::ToolInvocation Invocation(
         {std::string("find_all_symbols"), std::string("-fsyntax-only"),
          std::string("-std=c++11"), FileName},
         Factory->create(), Files.get(),
         std::make_shared<PCHContainerOperations>());
 
     InMemoryFileSystem->addFile(HeaderName, 0,
-                                llvm::MemoryBuffer::getMemBuffer(Code));
+                                llvm::MemoryBuffer::getMemBuffer(HeaderCode));
 
     std::string Content = "#include\"" + std::string(HeaderName) +
                           "\"\n"
                           "#include \"" +
                           InternalHeader + "\"";
 #if !defined(_MSC_VER) && !defined(__MINGW32__)
     // Test path cleaning for both decls and macros.
     const std::string DirtyHeader = "./internal/./a/b.h";
     Content += "\n#include \"" + DirtyHeader + "\"";
     const std::string CleanHeader = "internal/a/b.h";
     const std::string DirtyHeaderContent =
         "#define INTERNAL 1\nclass ExtraInternal {};";
     InMemoryFileSystem->addFile(
         DirtyHeader, 0, llvm::MemoryBuffer::getMemBuffer(DirtyHeaderContent));
     SymbolInfo DirtyMacro("INTERNAL", SymbolInfo::SymbolKind::Macro,
                           CleanHeader, 1, {});
     SymbolInfo DirtySymbol("ExtraInternal", SymbolInfo::SymbolKind::Class,
                            CleanHeader, 2, {});
 #endif // _MSC_VER && __MINGW32__
+    Content += "\n" + MainCode.str();
     InMemoryFileSystem->addFile(FileName, 0,
                                 llvm::MemoryBuffer::getMemBuffer(Content));
     Invocation.run();
     EXPECT_TRUE(hasSymbol(InternalSymbol));
     EXPECT_TRUE(hasSymbol(IncSymbol));
 #if !defined(_MSC_VER) && !defined(__MINGW32__)
     EXPECT_TRUE(hasSymbol(DirtySymbol));
     EXPECT_TRUE(hasSymbol(DirtyMacro));
 #endif  // _MSC_VER && __MINGW32__
     return true;
   }
 
 protected:
   TestSymbolReporter Reporter;
 };
 
 TEST_F(FindAllSymbolsTest, VariableSymbols) {
-  static const char Code[] = R"(
+  static const char Header[] = R"(
       extern int xargc;
       namespace na {
       static bool SSSS = false;
       namespace nb { const long long *XXXX; }
       })";
-  runFindAllSymbols(Code);
+  static const char Main[] = R"(
+      auto y = &na::nb::XXXX;
+      int main() { if (na::SSSS) return xargc; }
+  )";
+  runFindAllSymbols(Header, Main);
 
   SymbolInfo Symbol =
       SymbolInfo("xargc", SymbolInfo::SymbolKind::Variable, HeaderName, 2, {});
   EXPECT_TRUE(hasSymbol(Symbol));
+  EXPECT_TRUE(hasUse(Symbol));
 
   Symbol = SymbolInfo("SSSS", SymbolInfo::SymbolKind::Variable, HeaderName, 4,
                       {{SymbolInfo::ContextType::Namespace, "na"}});
   EXPECT_TRUE(hasSymbol(Symbol));
+  EXPECT_TRUE(hasUse(Symbol));
 
   Symbol = SymbolInfo("XXXX", SymbolInfo::SymbolKind::Variable, HeaderName, 5,
                       {{SymbolInfo::ContextType::Namespace, "nb"},
                        {SymbolInfo::ContextType::Namespace, "na"}});
   EXPECT_TRUE(hasSymbol(Symbol));
+  EXPECT_TRUE(hasUse(Symbol));
 }
 
 TEST_F(FindAllSymbolsTest, ExternCSymbols) {
-  static const char Code[] = R"(
+  static const char Header[] = R"(
       extern "C" {
       int C_Func() { return 0; }
       struct C_struct {
         int Member;
       };
       })";
-  runFindAllSymbols(Code);
+  static const char Main[] = R"(
+      C_struct q() {
+        int(*ptr)() = C_Func;
+        return {0};
+      }
+  )";
+  runFindAllSymbols(Header, Main);
 
   SymbolInfo Symbol =
       SymbolInfo("C_Func", SymbolInfo::SymbolKind::Function, HeaderName, 3, {});
   EXPECT_TRUE(hasSymbol(Symbol));
+  EXPECT_TRUE(hasUse(Symbol));
 
   Symbol =
       SymbolInfo("C_struct", SymbolInfo::SymbolKind::Class, HeaderName, 4, {});
   EXPECT_TRUE(hasSymbol(Symbol));
+  EXPECT_TRUE(hasUse(Symbol));
 }
 
 TEST_F(FindAllSymbolsTest, CXXRecordSymbols) {
-  static const char Code[] = R"(
+  static const char Header[] = R"(
       struct Glob {};
       struct A; // Not a defintion, ignored.
       class NOP; // Not a defintion, ignored
       namespace na {
       struct A {
         struct AAAA {};
         int x;
         int y;
         void f() {}
       };
       };  //
       )";
-  runFindAllSymbols(Code);
+  static const char Main[] = R"(
+      static Glob glob;
+      static na::A::AAAA* a;
+  )";
+  runFindAllSymbols(Header, Main);
 
   SymbolInfo Symbol =
       SymbolInfo("Glob", SymbolInfo::SymbolKind::Class, HeaderName, 2, {});
   EXPECT_TRUE(hasSymbol(Symbol));
+  EXPECT_TRUE(hasUse(Symbol));
 
   Symbol = SymbolInfo("A", SymbolInfo::SymbolKind::Class, HeaderName, 6,
                       {{SymbolInfo::ContextType::Namespace, "na"}});
   EXPECT_TRUE(hasSymbol(Symbol));
+  EXPECT_TRUE(hasUse(Symbol));
 
   Symbol = SymbolInfo("AAA", SymbolInfo::SymbolKind::Class, HeaderName, 7,
                       {{SymbolInfo::ContextType::Record, "A"},
                        {SymbolInfo::ContextType::Namespace, "na"}});
   EXPECT_FALSE(hasSymbol(Symbol));
+  EXPECT_FALSE(hasUse(Symbol));
 }
 
 TEST_F(FindAllSymbolsTest, CXXRecordSymbolsTemplate) {
-  static const char Code[] = R"(
+  static const char Header[] = R"(
       template <typename T>
-      class T_TEMP {
+      struct T_TEMP {
         template <typename _Tp1>
         struct rebind { typedef T_TEMP<_Tp1> other; };
       };
       // Ignore specialization.
       template class T_TEMP<char>;
 
       template <typename T>
       class Observer {
       };
       // Ignore specialization.
       template <> class Observer<int> {};
       )";
-  runFindAllSymbols(Code);
+  static const char Main[] = R"(
+      extern T_TEMP<int>::rebind<char> weirdo;
+  )";
+  runFindAllSymbols(Header, Main);
 
   SymbolInfo Symbol =
       SymbolInfo("T_TEMP", SymbolInfo::SymbolKind::Class, HeaderName, 3, {});
   EXPECT_TRUE(hasSymbol(Symbol));
+  EXPECT_TRUE(hasUse(Symbol));
 }
 
 TEST_F(FindAllSymbolsTest, DontIgnoreTemplatePartialSpecialization) {
   static const char Code[] = R"(
       template<class> class Class; // undefined
       template<class R, class... ArgTypes>
       class Class<R(ArgTypes...)> {
       };
 
       template<class T> void f() {};
       template<> void f<int>() {};
       )";
-  runFindAllSymbols(Code);
+  runFindAllSymbols(Code, "");
   SymbolInfo Symbol =
       SymbolInfo("Class", SymbolInfo::SymbolKind::Class, HeaderName, 4, {});
   EXPECT_TRUE(hasSymbol(Symbol));
   Symbol =
       SymbolInfo("f", SymbolInfo::SymbolKind::Function, HeaderName, 7, {});
   EXPECT_TRUE(hasSymbol(Symbol));
   Symbol =
       SymbolInfo("f", SymbolInfo::SymbolKind::Function, HeaderName, 8, {});
   EXPECT_FALSE(hasSymbol(Symbol));
 }
 
 TEST_F(FindAllSymbolsTest, FunctionSymbols) {
-  static const char Code[] = R"(
+  static const char Header[] = R"(
       namespace na {
       int gg(int);
       int f(const int &a) { int Local; static int StaticLocal; return 0; }
       static void SSSFFF() {}
       }  // namespace na
       namespace na {
       namespace nb {
       template<typename T>
       void fun(T t) {};
       } // namespace nb
       } // namespace na";
       )";
-  runFindAllSymbols(Code);
+  static const char Main[] = R"(
+      int(*gg)(int) = &na::gg;
+      int main() {
+        (void)na::SSSFFF;
+        na::nb::fun(0);
+        return na::f(gg(0));
+      }
+  )";
+  runFindAllSymbols(Header, Main);
 
   SymbolInfo Symbol =
       SymbolInfo("gg", SymbolInfo::SymbolKind::Function, HeaderName, 3,
                  {{SymbolInfo::ContextType::Namespace, "na"}});
   EXPECT_TRUE(hasSymbol(Symbol));
+  EXPECT_TRUE(hasUse(Symbol));
 
   Symbol = SymbolInfo("f", SymbolInfo::SymbolKind::Function, HeaderName, 4,
                       {{SymbolInfo::ContextType::Namespace, "na"}});
   EXPECT_TRUE(hasSymbol(Symbol));
+  EXPECT_TRUE(hasUse(Symbol));
 
   Symbol = SymbolInfo("SSSFFF", SymbolInfo::SymbolKind::Function, HeaderName, 5,
                       {{SymbolInfo::ContextType::Namespace, "na"}});
   EXPECT_TRUE(hasSymbol(Symbol));
+  EXPECT_TRUE(hasUse(Symbol));
 
   Symbol = SymbolInfo("fun", SymbolInfo::SymbolKind::Function, HeaderName, 10,
                       {{SymbolInfo::ContextType::Namespace, "nb"},
                        {SymbolInfo::ContextType::Namespace, "na"}});
   EXPECT_TRUE(hasSymbol(Symbol));
+  EXPECT_TRUE(hasUse(Symbol));
 }
 
 TEST_F(FindAllSymbolsTest, NamespaceTest) {
-  static const char Code[] = R"(
+  static const char Header[] = R"(
       int X1;
       namespace { int X2; }
       namespace { namespace { int X3; } }
       namespace { namespace nb { int X4; } }
       namespace na { inline namespace __1 { int X5; } }
       )";
-  runFindAllSymbols(Code);
+  static const char Main[] = R"(
+      using namespace nb;
+      int main() {
+        X1 = X2;
+        X3 = X4;
+        (void)na::X5;
+      }
+  )";
+  runFindAllSymbols(Header, Main);
 
   SymbolInfo Symbol =
       SymbolInfo("X1", SymbolInfo::SymbolKind::Variable, HeaderName, 2, {});
   EXPECT_TRUE(hasSymbol(Symbol));
+  EXPECT_TRUE(hasUse(Symbol));
 
   Symbol = SymbolInfo("X2", SymbolInfo::SymbolKind::Variable, HeaderName, 3,
                       {{SymbolInfo::ContextType::Namespace, ""}});
   EXPECT_TRUE(hasSymbol(Symbol));
+  EXPECT_TRUE(hasUse(Symbol));
 
   Symbol = SymbolInfo("X3", SymbolInfo::SymbolKind::Variable, HeaderName, 4,
                       {{SymbolInfo::ContextType::Namespace, ""},
                        {SymbolInfo::ContextType::Namespace, ""}});
   EXPECT_TRUE(hasSymbol(Symbol));
+  EXPECT_TRUE(hasUse(Symbol));
 
   Symbol = SymbolInfo("X4", SymbolInfo::SymbolKind::Variable, HeaderName, 5,
                       {{SymbolInfo::ContextType::Namespace, "nb"},
                        {SymbolInfo::ContextType::Namespace, ""}});
   EXPECT_TRUE(hasSymbol(Symbol));
+  EXPECT_TRUE(hasUse(Symbol));
 
   Symbol = SymbolInfo("X5", SymbolInfo::SymbolKind::Variable, HeaderName, 6,
                       {{SymbolInfo::ContextType::Namespace, "na"}});
   EXPECT_TRUE(hasSymbol(Symbol));
+  EXPECT_TRUE(hasUse(Symbol));
 }
 
 TEST_F(FindAllSymbolsTest, DecayedTypeTest) {
-  static const char Code[] = "void DecayedFunc(int x[], int y[10]) {}";
-  runFindAllSymbols(Code);
+  static const char Header[] = "void DecayedFunc(int x[], int y[10]) {}";
+  static const char Main[] = R"(int main() { DecayedFunc(nullptr, nullptr); })";
+  runFindAllSymbols(Header, Main);
   SymbolInfo Symbol = SymbolInfo(
       "DecayedFunc", SymbolInfo::SymbolKind::Function, HeaderName, 1, {});
   EXPECT_TRUE(hasSymbol(Symbol));
+  EXPECT_TRUE(hasUse(Symbol));
 }
 
 TEST_F(FindAllSymbolsTest, CTypedefTest) {
-  static const char Code[] = R"(
+  static const char Header[] = R"(
       typedef unsigned size_t_;
       typedef struct { int x; } X;
       using XX = X;
       )";
-  runFindAllSymbols(Code);
+  static const char Main[] = R"(
+      size_t_ f;
+      template<typename T> struct vector{};
+      vector<X> list;
+      void foo(const XX&){}
+  )";
+  runFindAllSymbols(Header, Main);
 
   SymbolInfo Symbol = SymbolInfo("size_t_", SymbolInfo::SymbolKind::TypedefName,
                                  HeaderName, 2, {});
   EXPECT_TRUE(hasSymbol(Symbol));
+  EXPECT_TRUE(hasUse(Symbol));
 
   Symbol =
       SymbolInfo("X", SymbolInfo::SymbolKind::TypedefName, HeaderName, 3, {});
   EXPECT_TRUE(hasSymbol(Symbol));
+  EXPECT_TRUE(hasUse(Symbol));
 
   Symbol =
       SymbolInfo("XX", SymbolInfo::SymbolKind::TypedefName, HeaderName, 4, {});
   EXPECT_TRUE(hasSymbol(Symbol));
+  EXPECT_TRUE(hasUse(Symbol));
 }
 
 TEST_F(FindAllSymbolsTest, EnumTest) {
-  static const char Code[] = R"(
+  static const char Header[] = R"(
       enum Glob_E { G1, G2 };
       enum class Altitude { high='h', low='l'};
       enum { A1, A2 };
       class A {
       public:
         enum A_ENUM { X1, X2 };
       };
       enum DECL : int;
       )";
-  runFindAllSymbols(Code);
+  static const char Main[] = R"(
+      static auto flags = G1 | G2;
+      static auto alt = Altitude::high;
+      static auto nested = A::X1;
+      extern DECL whatever;
+      static auto flags2 = A1 | A2;
+  )";
+  runFindAllSymbols(Header, Main);
 
   SymbolInfo Symbol =
       SymbolInfo("Glob_E", SymbolInfo::SymbolKind::EnumDecl, HeaderName, 2, {});
   EXPECT_TRUE(hasSymbol(Symbol));
+  EXPECT_FALSE(hasUse(Symbol));
 
   Symbol =
       SymbolInfo("G1", SymbolInfo::SymbolKind::EnumConstantDecl, HeaderName, 2,
                  {{SymbolInfo::ContextType::EnumDecl, "Glob_E"}});
   EXPECT_TRUE(hasSymbol(Symbol));
+  EXPECT_TRUE(hasUse(Symbol));
 
   Symbol =
       SymbolInfo("G2", SymbolInfo::SymbolKind::EnumConstantDecl, HeaderName, 2,
                  {{SymbolInfo::ContextType::EnumDecl, "Glob_E"}});
   EXPECT_TRUE(hasSymbol(Symbol));
+  EXPECT_TRUE(hasUse(Symbol));
 
   Symbol = SymbolInfo("Altitude", SymbolInfo::SymbolKind::EnumDecl, HeaderName,
                       3, {});
   EXPECT_TRUE(hasSymbol(Symbol));
+  EXPECT_TRUE(hasUse(Symbol));
   Symbol =
       SymbolInfo("high", SymbolInfo::SymbolKind::EnumConstantDecl, HeaderName,
                  3, {{SymbolInfo::ContextType::EnumDecl, "Altitude"}});
   EXPECT_FALSE(hasSymbol(Symbol));
+  EXPECT_FALSE(hasUse(Symbol));
 
   Symbol = SymbolInfo("A1", SymbolInfo::SymbolKind::EnumConstantDecl,
                       HeaderName, 4, {{SymbolInfo::ContextType::EnumDecl, ""}});
   EXPECT_TRUE(hasSymbol(Symbol));
+  EXPECT_TRUE(hasUse(Symbol));
   Symbol = SymbolInfo("A2", SymbolInfo::SymbolKind::EnumConstantDecl,
                       HeaderName, 4, {{SymbolInfo::ContextType::EnumDecl, ""}});
   EXPECT_TRUE(hasSymbol(Symbol));
+  EXPECT_TRUE(hasUse(Symbol));
   Symbol = SymbolInfo("", SymbolInfo::SymbolKind::EnumDecl, HeaderName, 4, {});
   EXPECT_FALSE(hasSymbol(Symbol));
+  EXPECT_FALSE(hasUse(Symbol));
 
   Symbol = SymbolInfo("A_ENUM", SymbolInfo::SymbolKind::EnumDecl, HeaderName, 7,
                       {{SymbolInfo::ContextType::Record, "A"}});
   EXPECT_FALSE(hasSymbol(Symbol));
+  EXPECT_FALSE(hasUse(Symbol));
 
   Symbol = SymbolInfo("X1", SymbolInfo::SymbolKind::EnumDecl, HeaderName, 7,
                       {{SymbolInfo::ContextType::EnumDecl, "A_ENUM"},
                        {SymbolInfo::ContextType::Record, "A"}});
   EXPECT_FALSE(hasSymbol(Symbol));
 
   Symbol =
       SymbolInfo("DECL", SymbolInfo::SymbolKind::EnumDecl, HeaderName, 9, {});
   EXPECT_FALSE(hasSymbol(Symbol));
 }
 
 TEST_F(FindAllSymbolsTest, IWYUPrivatePragmaTest) {
-  static const char Code[] = R"(
+  static const char Header[] = R"(
     // IWYU pragma: private, include "bar.h"
     struct Bar {
     };
   )";
-  runFindAllSymbols(Code);
+  static const char Main[] = R"(
+    Bar bar;
+  )";
+  runFindAllSymbols(Header, Main);
 
   SymbolInfo Symbol =
       SymbolInfo("Bar", SymbolInfo::SymbolKind::Class, "bar.h", 3, {});
   EXPECT_TRUE(hasSymbol(Symbol));
+  EXPECT_TRUE(hasUse(Symbol));
 }
 
 TEST_F(FindAllSymbolsTest, MacroTest) {
-  static const char Code[] = R"(
+  static const char Header[] = R"(
     #define X
     #define Y 1
     #define MAX(X, Y) ((X) > (Y) ? (X) : (Y))
   )";
-  runFindAllSymbols(Code);
+  static const char Main[] = R"(
+    #ifdef X
+    int main() { return MAX(0,Y); }
+    #endif
+  )";
+  runFindAllSymbols(Header, Main);
   SymbolInfo Symbol =
       SymbolInfo("X", SymbolInfo::SymbolKind::Macro, HeaderName, 2, {});
   EXPECT_TRUE(hasSymbol(Symbol));
+  EXPECT_TRUE(hasUse(Symbol));
 
   Symbol = SymbolInfo("Y", SymbolInfo::SymbolKind::Macro, HeaderName, 3, {});
   EXPECT_TRUE(hasSymbol(Symbol));
+  EXPECT_TRUE(hasUse(Symbol));
 
   Symbol = SymbolInfo("MAX", SymbolInfo::SymbolKind::Macro, HeaderName, 4, {});
   EXPECT_TRUE(hasSymbol(Symbol));
+  EXPECT_TRUE(hasUse(Symbol));
 }
 
 TEST_F(FindAllSymbolsTest, MacroTestWithIWYU) {
-  static const char Code[] = R"(
+  static const char Header[] = R"(
     // IWYU pragma: private, include "bar.h"
-    #define X
+    #define X 1
     #define Y 1
     #define MAX(X, Y) ((X) > (Y) ? (X) : (Y))
   )";
-  runFindAllSymbols(Code);
+  static const char Main[] = R"(
+    #ifdef X
+    int main() { return MAX(0,Y); }
+    #endif
+  )";
+  runFindAllSymbols(Header, Main);
   SymbolInfo Symbol =
       SymbolInfo("X", SymbolInfo::SymbolKind::Macro, "bar.h", 3, {});
   EXPECT_TRUE(hasSymbol(Symbol));
+  EXPECT_TRUE(hasUse(Symbol));
 
   Symbol = SymbolInfo("Y", SymbolInfo::SymbolKind::Macro, "bar.h", 4, {});
   EXPECT_TRUE(hasSymbol(Symbol));
+  EXPECT_TRUE(hasUse(Symbol));
 
   Symbol = SymbolInfo("MAX", SymbolInfo::SymbolKind::Macro, "bar.h", 5, {});
   EXPECT_TRUE(hasSymbol(Symbol));
+  EXPECT_TRUE(hasUse(Symbol));
 }
 
 TEST_F(FindAllSymbolsTest, NoFriendTest) {
-  static const char Code[] = R"(
+  static const char Header[] = R"(
     class WorstFriend {
       friend void Friend();
       friend class BestFriend;
     };
   )";
-  runFindAllSymbols(Code);
+  runFindAllSymbols(Header, "");
   SymbolInfo Symbol = SymbolInfo("WorstFriend", SymbolInfo::SymbolKind::Class,
                                  HeaderName, 2, {});
   EXPECT_TRUE(hasSymbol(Symbol));
 
   Symbol = SymbolInfo("Friend", SymbolInfo::SymbolKind::Function, HeaderName,
                       3, {});
   EXPECT_FALSE(hasSymbol(Symbol));
 
   Symbol = SymbolInfo("BestFriend", SymbolInfo::SymbolKind::Class, HeaderName,
                       4, {});
   EXPECT_FALSE(hasSymbol(Symbol));
 }
 
 } // namespace find_all_symbols
 } // namespace clang