[include-fixer] Remove line number from Symbol identity

[sammccall]

Summary

Remove line number from Symbol identity.

For our purposes (include-fixer and clangd autocomplete), function overloads
within the same header should mostly be treated as a single combined symbol.

We may want to track individual occurrences (line number, full type info)
and aggregate this during mapreduce, but that's not done here.

[hokein]

We may want to track individual occurrences (line number, full type info)
and aggregate this during mapreduce, but that's not done here.

Seems reasonable. So we will introduce a new structure to track these occurrences? Or reuse the SymbolInfo::Signals?

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

45

With the change, the name is not a suitable name as it returns to the number of times. Maybe rename it ("symbolSeenTimes"). The same below.

[sammccall]

Address review comments. Uncovered two bugs:

• accidentally casting through bool: EXPECT_EQ(1, hasSymbol) was a lie
• we were double counting uses of typedefs where the underlying type was built in, because qualType(hasDeclaration) stops at the typedef in this case.

[sammccall]

In D30685#695284, @hokein wrote:

We may want to track individual occurrences (line number, full type info)
and aggregate this during mapreduce, but that's not done here.

Seems reasonable. So we will introduce a new structure to track these occurrences? Or reuse the SymbolInfo::Signals?

These aren't really signals, but they're more like map-value than map-key. I suspect it's another new struct. Fortunately we don't actually need it yet.

[hokein]

LGTM once Ben has no other comments. Be careful before submitting it (this patch also changes the interface).

[bkramer]

lg

include-fixer/IncludeFixer.cpp

IncludeFixerContext IncludeFixerSemaSource::getIncludeFixerContext(
   std::vector<find_all_symbols::SymbolInfo> SymbolCandidates;
   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());
+                                  MinimizedFilePath, 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/find-all-symbols/FindAllMacros.cpp

 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()), {});
+                    SymbolInfo::SymbolKind::Macro, FilePath, {});
 }
 
 void FindAllMacros::MacroDefined(const Token &MacroNameTok,
                                  const MacroDirective *MD) {
   if (auto Symbol = CreateMacroSymbol(MacroNameTok, MD->getMacroInfo()))
     ++FileSymbols[*Symbol].Seen;
 }
 

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

llvm::errs() << "Declaration " << ND->getNameAsString() << "("
                  << ND->getDeclKindName()
                  << ") has invalid declaration location.";
     return llvm::None;
   }
 
   std::string FilePath = getIncludePath(SM, Loc, Collector);
   if (FilePath.empty()) return llvm::None;
 
-  return SymbolInfo(ND->getNameAsString(), Type, FilePath,
-                    SM.getExpansionLineNumber(Loc), GetContexts(ND));
+  return SymbolInfo(ND->getNameAsString(), Type, FilePath, GetContexts(ND));
 }
 
 } // namespace
 
 void FindAllSymbols::registerMatchers(MatchFinder *MatchFinder) {
   // FIXME: Handle specialization.
   auto IsInSpecialization = hasAncestor(
       decl(anyOf(cxxRecordDecl(isExplicitTemplateSpecialization()),
void FindAllSymbols::registerMatchers(MatchFinder *MatchFinder) {
   // 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 Types = namedDecl(anyOf(CRecords, CXXRecords, Enums));
   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(
       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.
+  // Uses of typedefs: these are often 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(

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.
+/// \brief Describes a named symbol from a header.
+/// Symbols with the same qualified name and type (e.g. function overloads)
+/// that appear in the same header are represented by a single SymbolInfo.
+///
+/// TODO: keep track of instances, e.g. overload locations and signatures.
 class SymbolInfo {
 public:
   /// \brief The SymbolInfo Type.
   enum class SymbolKind {
     Function,
     Class,
     Variable,
     TypedefName,
struct Signals {
     Signals operator+(const Signals &RHS) const;
     bool 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() : Type(SymbolKind::Unknown) {}
 
   SymbolInfo(llvm::StringRef Name, SymbolKind Type, llvm::StringRef FilePath,
-             int LineNumber, const std::vector<Context> &Contexts);
+             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; }
-
   bool operator<(const SymbolInfo &Symbol) const;
 
   bool operator==(const SymbolInfo &Symbol) const;
 
 private:
   friend struct llvm::yaml::MappingTraits<struct SymbolAndSignals>;
 
   /// \brief Identifier name.
private:
   /// For example, if a symbol 'x' is declared as:
   ///     namespace na { namespace nb { class A { int x; } } }
   /// The contexts would be { {RECORD, "A"}, {NAMESPACE, "nb"}, {NAMESPACE,
   /// "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;
 };
 
 struct SymbolAndSignals {
   SymbolInfo Symbol;
   SymbolInfo::Signals Signals;
   bool operator==(const SymbolAndSignals& RHS) const;
 };
 

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

 
 namespace llvm {
 namespace yaml {
 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) {

 
 } // namespace yaml
 } // namespace llvm
 
 namespace clang {
 namespace find_all_symbols {
 
 SymbolInfo::SymbolInfo(llvm::StringRef Name, SymbolKind Type,
-                       llvm::StringRef FilePath, int LineNumber,
+                       llvm::StringRef FilePath,
                        const std::vector<Context> &Contexts)
-    : Name(Name), Type(Type), FilePath(FilePath), Contexts(Contexts),
-      LineNumber(LineNumber) {}
+    : Name(Name), Type(Type), FilePath(FilePath), Contexts(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);
+  return std::tie(Name, Type, FilePath, Contexts) ==
+         std::tie(Symbol.Name, Symbol.Type, Symbol.FilePath, 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);
+  return std::tie(Name, Type, FilePath, Contexts) <
+         std::tie(Symbol.Name, Symbol.Type, Symbol.FilePath, 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;

include-fixer/tool/ClangIncludeFixer.cpp

case fixed: {
     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(
             {SymbolInfo(Split.first.trim(), SymbolInfo::SymbolKind::Unknown,
-                        CommaSplits[I].trim(), 1, {}),
+                        CommaSplits[I].trim(), {}),
              // 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;

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
 Seen:            1
 Used:            0
 ---
 Name:           bar
 Contexts:
   - ContextType:     Namespace
     ContextName:     a
   - ContextType:     Namespace
     ContextName:     b
 FilePath:        ../include/bar.h
-LineNumber:      1
 Type:            Class
 Seen:            1
 Used:            0
 ---
 Name:           bar
 Contexts:
   - ContextType:     Namespace
     ContextName:     a
   - ContextType:     Namespace
     ContextName:     b
 FilePath:        ../include/bar.h
-LineNumber:      2
 Type:            Class
 Seen:            3
 Used:            0
 ---
 Name:           bar
 Contexts:
   - ContextType:     Namespace
     ContextName:     a
   - ContextType:     Namespace
     ContextName:     b
 FilePath:        ../include/zbar.h
-LineNumber:      1
 Type:            Class
 Seen:            3
 Used:            0
 ---
 Name:           b
 Contexts:
 FilePath:        var.h
-LineNumber:      1
 Type:            Variable
 Seen:            1
 Used:            0
 ---
 Name:            bar
 Contexts:
   - ContextType:    Namespace
     ContextName:    c
 FilePath:        test/include-fixer/baz.h
-LineNumber:      1
 Type:            Class
 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
 Seen:            1
 Used:            1
 ...
 ---
 Name:           bar
 Contexts:
   - ContextType:     Namespace
     ContextName:     a
 FilePath:        ../include/bar.h
-LineNumber:      1
 Type:            Class
 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
 Seen:            1
 Used:            2
 ...
 ---
 Name:           bar
 Contexts:
   - ContextType:     Namespace
     ContextName:     a
 FilePath:        ../include/barbar.h
-LineNumber:      1
 Type:            Class
 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
 Seen:            1
 Used:            1
 ...
 ---
 Name:            bar
 Contexts:        
   - ContextType:     Namespace
     ContextName:     a
 FilePath:        ../include/barbar.h
-LineNumber:      1
 Type:            Class
 Seen:            1
 Used:            0
 ...
 ---
 Name:            foo
 Contexts:        
   - ContextType:     Namespace
     ContextName:     a
 FilePath:        foo.h
-LineNumber:      1
 Type:            Class
 Seen:            2
 Used:            2
 ...

unittests/include-fixer/IncludeFixerTest.cpp

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<SymbolAndSignals> Symbols = {
-      {SymbolInfo("string", SymbolInfo::SymbolKind::Class, "<string>", 1,
+      {SymbolInfo("string", SymbolInfo::SymbolKind::Class, "<string>",
                   {{SymbolInfo::ContextType::Namespace, "std"}}),
        SymbolInfo::Signals{}},
-      {SymbolInfo("sting", SymbolInfo::SymbolKind::Class, "\"sting\"", 1,
+      {SymbolInfo("sting", SymbolInfo::SymbolKind::Class, "\"sting\"",
                   {{SymbolInfo::ContextType::Namespace, "std"}}),
        SymbolInfo::Signals{}},
       {SymbolInfo("foo", SymbolInfo::SymbolKind::Class,
-                  "\"dir/otherdir/qux.h\"", 1,
+                  "\"dir/otherdir/qux.h\"",
                   {{SymbolInfo::ContextType::Namespace, "b"},
                    {SymbolInfo::ContextType::Namespace, "a"}}),
        SymbolInfo::Signals{}},
-      {SymbolInfo("bar", SymbolInfo::SymbolKind::Class, "\"bar.h\"", 1,
+      {SymbolInfo("bar", SymbolInfo::SymbolKind::Class, "\"bar.h\"",
                   {{SymbolInfo::ContextType::Namespace, "b"},
                    {SymbolInfo::ContextType::Namespace, "a"}}),
        SymbolInfo::Signals{}},
-      {SymbolInfo("bar", SymbolInfo::SymbolKind::Class, "\"bar2.h\"", 1,
+      {SymbolInfo("bar", SymbolInfo::SymbolKind::Class, "\"bar2.h\"",
                   {{SymbolInfo::ContextType::Namespace, "c"},
                    {SymbolInfo::ContextType::Namespace, "a"}}),
        SymbolInfo::Signals{}},
-      {SymbolInfo("Green", SymbolInfo::SymbolKind::Class, "\"color.h\"", 1,
+      {SymbolInfo("Green", SymbolInfo::SymbolKind::Class, "\"color.h\"",
                   {{SymbolInfo::ContextType::EnumDecl, "Color"},
                    {SymbolInfo::ContextType::Namespace, "b"},
                    {SymbolInfo::ContextType::Namespace, "a"}}),
        SymbolInfo::Signals{}},
-      {SymbolInfo("Vector", SymbolInfo::SymbolKind::Class, "\"Vector.h\"", 1,
+      {SymbolInfo("Vector", SymbolInfo::SymbolKind::Class, "\"Vector.h\"",
                   {{SymbolInfo::ContextType::Namespace, "__a"},
                    {SymbolInfo::ContextType::Namespace, "a"}}),
        SymbolInfo::Signals{/*Seen=*/2, 0}},
-      {SymbolInfo("Vector", SymbolInfo::SymbolKind::Class, "\"Vector.h\"", 2,
+      {SymbolInfo("Vector", SymbolInfo::SymbolKind::Class, "\"Vector.h\"",
                   {{SymbolInfo::ContextType::Namespace, "a"}}),
        SymbolInfo::Signals{/*Seen=*/2, 0}},
-      {SymbolInfo("StrCat", SymbolInfo::SymbolKind::Class, "\"strcat.h\"", 1,
+      {SymbolInfo("StrCat", SymbolInfo::SymbolKind::Class, "\"strcat.h\"",
                   {{SymbolInfo::ContextType::Namespace, "str"}}),
        SymbolInfo::Signals{}},
-      {SymbolInfo("str", SymbolInfo::SymbolKind::Class, "\"str.h\"", 1, {}),
+      {SymbolInfo("str", SymbolInfo::SymbolKind::Class, "\"str.h\"", {}),
        SymbolInfo::Signals{}},
-      {SymbolInfo("foo2", SymbolInfo::SymbolKind::Class, "\"foo2.h\"", 1, {}),
+      {SymbolInfo("foo2", SymbolInfo::SymbolKind::Class, "\"foo2.h\"", {}),
        SymbolInfo::Signals{}},
   };
   auto SymbolIndexMgr = llvm::make_unique<SymbolIndexManager>();
   SymbolIndexMgr->addSymbolIndex(
       [=]() { return llvm::make_unique<InMemorySymbolIndex>(Symbols); });
 
   std::vector<IncludeFixerContext> FixerContexts;
   IncludeFixerActionFactory Factory(*SymbolIndexMgr, FixerContexts, "llvm");

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

public:
   ~TestSymbolReporter() override {}
 
   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 {
+  int seen(const SymbolInfo &Symbol) const {
     auto it = Symbols.find(Symbol);
-    return it != Symbols.end() && it->second.Seen > 0;
+    return it == Symbols.end() ? 0 : it->second.Seen;
   }
 
-  bool hasUse(const SymbolInfo &Symbol) const {
+  int used(const SymbolInfo &Symbol) const {
     auto it = Symbols.find(Symbol);
-    return it != Symbols.end() && it->second.Used > 0;
+    return it == Symbols.end() ? 0 : it->second.Used;
   }
 
 private:
   SymbolInfo::SignalMap Symbols;
 };
 
 class FindAllSymbolsTest : public ::testing::Test {
 public:
-  bool hasSymbol(const SymbolInfo &Symbol) {
-    return Reporter.hasSymbol(Symbol);
-  }
+  int seen(const SymbolInfo &Symbol) { return Reporter.seen(Symbol); }
 
-  bool hasUse(const SymbolInfo &Symbol) { return Reporter.hasUse(Symbol); }
+  int used(const SymbolInfo &Symbol) { return Reporter.used(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";
     const std::string TopHeader = "<top>";
     // Test .inc header path. The header for `IncHeaderClass` should be
     // internal.h, which will eventually be mapped to <top>.
     std::string IncHeader = "internal/private.inc";
     std::string IncHeaderCode = "class IncHeaderClass {};";
 
     HeaderMapCollector::RegexHeaderMap RegexMap = {
         {R"(internal_.*\.h$)", TopHeader.c_str()},
     };
 
     std::string InternalCode =
         "#include \"private.inc\"\nclass Internal {};";
     SymbolInfo InternalSymbol("Internal", SymbolInfo::SymbolKind::Class,
-                              TopHeader, 2, {});
+                              TopHeader, {});
     SymbolInfo IncSymbol("IncHeaderClass", SymbolInfo::SymbolKind::Class,
-                         TopHeader, 1, {});
+                         TopHeader, {});
     InMemoryFileSystem->addFile(
         IncHeader, 0, llvm::MemoryBuffer::getMemBuffer(IncHeaderCode));
     InMemoryFileSystem->addFile(InternalHeader, 0,
                                 llvm::MemoryBuffer::getMemBuffer(InternalCode));
 
     std::unique_ptr<tooling::FrontendActionFactory> Factory(
         new FindAllSymbolsActionFactory(&Reporter, &RegexMap));
 
#if !defined(_MSC_VER) && !defined(__MINGW32__)
     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, {});
+                          CleanHeader, {});
     SymbolInfo DirtySymbol("ExtraInternal", SymbolInfo::SymbolKind::Class,
-                           CleanHeader, 2, {});
+                           CleanHeader, {});
 #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));
+    EXPECT_EQ(1, seen(InternalSymbol));
+    EXPECT_EQ(1, seen(IncSymbol));
 #if !defined(_MSC_VER) && !defined(__MINGW32__)
-    EXPECT_TRUE(hasSymbol(DirtySymbol));
-    EXPECT_TRUE(hasSymbol(DirtyMacro));
+    EXPECT_EQ(1, seen(DirtySymbol));
+    EXPECT_EQ(1, seen(DirtyMacro));
 #endif  // _MSC_VER && __MINGW32__
     return true;
   }
 
 protected:
   TestSymbolReporter Reporter;
 };
 
 TEST_F(FindAllSymbolsTest, VariableSymbols) {
   static const char Header[] = R"(
       extern int xargc;
       namespace na {
       static bool SSSS = false;
       namespace nb { const long long *XXXX; }
       })";
   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));
+      SymbolInfo("xargc", SymbolInfo::SymbolKind::Variable, HeaderName, {});
+  EXPECT_EQ(1, seen(Symbol));
+  EXPECT_EQ(1, used(Symbol));
 
-  Symbol = SymbolInfo("SSSS", SymbolInfo::SymbolKind::Variable, HeaderName, 4,
+  Symbol = SymbolInfo("SSSS", SymbolInfo::SymbolKind::Variable, HeaderName,
                       {{SymbolInfo::ContextType::Namespace, "na"}});
-  EXPECT_TRUE(hasSymbol(Symbol));
-  EXPECT_TRUE(hasUse(Symbol));
+  EXPECT_EQ(1, seen(Symbol));
+  EXPECT_EQ(1, used(Symbol));
 
-  Symbol = SymbolInfo("XXXX", SymbolInfo::SymbolKind::Variable, HeaderName, 5,
+  Symbol = SymbolInfo("XXXX", SymbolInfo::SymbolKind::Variable, HeaderName,
                       {{SymbolInfo::ContextType::Namespace, "nb"},
                        {SymbolInfo::ContextType::Namespace, "na"}});
-  EXPECT_TRUE(hasSymbol(Symbol));
-  EXPECT_TRUE(hasUse(Symbol));
+  EXPECT_EQ(1, seen(Symbol));
+  EXPECT_EQ(1, used(Symbol));
 }
 
 TEST_F(FindAllSymbolsTest, ExternCSymbols) {
   static const char Header[] = R"(
       extern "C" {
       int C_Func() { return 0; }
       struct C_struct {
         int Member;
       };
       })";
   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));
+      SymbolInfo("C_Func", SymbolInfo::SymbolKind::Function, HeaderName, {});
+  EXPECT_EQ(1, seen(Symbol));
+  EXPECT_EQ(1, used(Symbol));
 
   Symbol =
-      SymbolInfo("C_struct", SymbolInfo::SymbolKind::Class, HeaderName, 4, {});
-  EXPECT_TRUE(hasSymbol(Symbol));
-  EXPECT_TRUE(hasUse(Symbol));
+      SymbolInfo("C_struct", SymbolInfo::SymbolKind::Class, HeaderName, {});
+  EXPECT_EQ(1, seen(Symbol));
+  EXPECT_EQ(1, used(Symbol));
 }
 
 TEST_F(FindAllSymbolsTest, CXXRecordSymbols) {
   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() {}
       };
       };  //
       )";
   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));
+      SymbolInfo("Glob", SymbolInfo::SymbolKind::Class, HeaderName, {});
+  EXPECT_EQ(1, seen(Symbol));
+  EXPECT_EQ(1, used(Symbol));
 
-  Symbol = SymbolInfo("A", SymbolInfo::SymbolKind::Class, HeaderName, 6,
+  Symbol = SymbolInfo("A", SymbolInfo::SymbolKind::Class, HeaderName,
                       {{SymbolInfo::ContextType::Namespace, "na"}});
-  EXPECT_TRUE(hasSymbol(Symbol));
-  EXPECT_TRUE(hasUse(Symbol));
+  EXPECT_EQ(1, seen(Symbol));
+  EXPECT_EQ(1, used(Symbol));
 
-  Symbol = SymbolInfo("AAA", SymbolInfo::SymbolKind::Class, HeaderName, 7,
+  Symbol = SymbolInfo("AAA", SymbolInfo::SymbolKind::Class, HeaderName,
                       {{SymbolInfo::ContextType::Record, "A"},
                        {SymbolInfo::ContextType::Namespace, "na"}});
-  EXPECT_FALSE(hasSymbol(Symbol));
-  EXPECT_FALSE(hasUse(Symbol));
+  EXPECT_EQ(0, seen(Symbol));
+  EXPECT_EQ(0, used(Symbol));
 }
 
 TEST_F(FindAllSymbolsTest, CXXRecordSymbolsTemplate) {
   static const char Header[] = R"(
       template <typename T>
       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> {};
       )";
   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));
+      SymbolInfo("T_TEMP", SymbolInfo::SymbolKind::Class, HeaderName, {});
+  EXPECT_EQ(1, seen(Symbol));
+  EXPECT_EQ(1, used(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, "");
   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));
+      SymbolInfo("Class", SymbolInfo::SymbolKind::Class, HeaderName, {});
+  EXPECT_EQ(1, seen(Symbol));
+  Symbol = SymbolInfo("f", SymbolInfo::SymbolKind::Function, HeaderName, {});
+  EXPECT_EQ(1, seen(Symbol));
 }
 
 TEST_F(FindAllSymbolsTest, FunctionSymbols) {
   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() {}
static const char Main[] = R"(
         (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("gg", SymbolInfo::SymbolKind::Function, HeaderName,
                  {{SymbolInfo::ContextType::Namespace, "na"}});
-  EXPECT_TRUE(hasSymbol(Symbol));
-  EXPECT_TRUE(hasUse(Symbol));
+  EXPECT_EQ(1, seen(Symbol));
+  EXPECT_EQ(1, used(Symbol));
 
-  Symbol = SymbolInfo("f", SymbolInfo::SymbolKind::Function, HeaderName, 4,
+  Symbol = SymbolInfo("f", SymbolInfo::SymbolKind::Function, HeaderName,
                       {{SymbolInfo::ContextType::Namespace, "na"}});
-  EXPECT_TRUE(hasSymbol(Symbol));
-  EXPECT_TRUE(hasUse(Symbol));
+  EXPECT_EQ(1, seen(Symbol));
+  EXPECT_EQ(1, used(Symbol));
 
-  Symbol = SymbolInfo("SSSFFF", SymbolInfo::SymbolKind::Function, HeaderName, 5,
+  Symbol = SymbolInfo("SSSFFF", SymbolInfo::SymbolKind::Function, HeaderName,
                       {{SymbolInfo::ContextType::Namespace, "na"}});
-  EXPECT_TRUE(hasSymbol(Symbol));
-  EXPECT_TRUE(hasUse(Symbol));
+  EXPECT_EQ(1, seen(Symbol));
+  EXPECT_EQ(1, used(Symbol));
 
-  Symbol = SymbolInfo("fun", SymbolInfo::SymbolKind::Function, HeaderName, 10,
+  Symbol = SymbolInfo("fun", SymbolInfo::SymbolKind::Function, HeaderName,
                       {{SymbolInfo::ContextType::Namespace, "nb"},
                        {SymbolInfo::ContextType::Namespace, "na"}});
-  EXPECT_TRUE(hasSymbol(Symbol));
-  EXPECT_TRUE(hasUse(Symbol));
+  EXPECT_EQ(1, seen(Symbol));
+  EXPECT_EQ(1, used(Symbol));
 }
 
 TEST_F(FindAllSymbolsTest, NamespaceTest) {
   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; } }
       )";
   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));
+      SymbolInfo("X1", SymbolInfo::SymbolKind::Variable, HeaderName, {});
+  EXPECT_EQ(1, seen(Symbol));
+  EXPECT_EQ(1, used(Symbol));
 
-  Symbol = SymbolInfo("X2", SymbolInfo::SymbolKind::Variable, HeaderName, 3,
+  Symbol = SymbolInfo("X2", SymbolInfo::SymbolKind::Variable, HeaderName,
                       {{SymbolInfo::ContextType::Namespace, ""}});
-  EXPECT_TRUE(hasSymbol(Symbol));
-  EXPECT_TRUE(hasUse(Symbol));
+  EXPECT_EQ(1, seen(Symbol));
+  EXPECT_EQ(1, used(Symbol));
 
-  Symbol = SymbolInfo("X3", SymbolInfo::SymbolKind::Variable, HeaderName, 4,
+  Symbol = SymbolInfo("X3", SymbolInfo::SymbolKind::Variable, HeaderName,
                       {{SymbolInfo::ContextType::Namespace, ""},
                        {SymbolInfo::ContextType::Namespace, ""}});
-  EXPECT_TRUE(hasSymbol(Symbol));
-  EXPECT_TRUE(hasUse(Symbol));
+  EXPECT_EQ(1, seen(Symbol));
+  EXPECT_EQ(1, used(Symbol));
 
-  Symbol = SymbolInfo("X4", SymbolInfo::SymbolKind::Variable, HeaderName, 5,
+  Symbol = SymbolInfo("X4", SymbolInfo::SymbolKind::Variable, HeaderName,
                       {{SymbolInfo::ContextType::Namespace, "nb"},
                        {SymbolInfo::ContextType::Namespace, ""}});
-  EXPECT_TRUE(hasSymbol(Symbol));
-  EXPECT_TRUE(hasUse(Symbol));
+  EXPECT_EQ(1, seen(Symbol));
+  EXPECT_EQ(1, used(Symbol));
 
-  Symbol = SymbolInfo("X5", SymbolInfo::SymbolKind::Variable, HeaderName, 6,
+  Symbol = SymbolInfo("X5", SymbolInfo::SymbolKind::Variable, HeaderName,
                       {{SymbolInfo::ContextType::Namespace, "na"}});
-  EXPECT_TRUE(hasSymbol(Symbol));
-  EXPECT_TRUE(hasUse(Symbol));
+  EXPECT_EQ(1, seen(Symbol));
+  EXPECT_EQ(1, used(Symbol));
 }
 
 TEST_F(FindAllSymbolsTest, DecayedTypeTest) {
   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));
+      "DecayedFunc", SymbolInfo::SymbolKind::Function, HeaderName, {});
+  EXPECT_EQ(1, seen(Symbol));
+  EXPECT_EQ(1, used(Symbol));
 }
 
 TEST_F(FindAllSymbolsTest, CTypedefTest) {
   static const char Header[] = R"(
       typedef unsigned size_t_;
       typedef struct { int x; } X;
       using XX = X;
       )";
   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));
+                                 HeaderName, {});
+  EXPECT_EQ(1, seen(Symbol));
+  EXPECT_EQ(1, used(Symbol));
+
+  Symbol = SymbolInfo("X", SymbolInfo::SymbolKind::TypedefName, HeaderName, {});
+  EXPECT_EQ(1, seen(Symbol));
+  EXPECT_EQ(1, used(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));
+      SymbolInfo("XX", SymbolInfo::SymbolKind::TypedefName, HeaderName, {});
+  EXPECT_EQ(1, seen(Symbol));
+  EXPECT_EQ(1, used(Symbol));
 }
 
 TEST_F(FindAllSymbolsTest, EnumTest) {
   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;
       )";
   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));
+      SymbolInfo("Glob_E", SymbolInfo::SymbolKind::EnumDecl, HeaderName, {});
+  EXPECT_EQ(1, seen(Symbol));
+  EXPECT_EQ(0, used(Symbol));
 
   Symbol =
-      SymbolInfo("G1", SymbolInfo::SymbolKind::EnumConstantDecl, HeaderName, 2,
+      SymbolInfo("G1", SymbolInfo::SymbolKind::EnumConstantDecl, HeaderName,
                  {{SymbolInfo::ContextType::EnumDecl, "Glob_E"}});
-  EXPECT_TRUE(hasSymbol(Symbol));
-  EXPECT_TRUE(hasUse(Symbol));
+  EXPECT_EQ(1, seen(Symbol));
+  EXPECT_EQ(1, used(Symbol));
 
   Symbol =
-      SymbolInfo("G2", SymbolInfo::SymbolKind::EnumConstantDecl, HeaderName, 2,
+      SymbolInfo("G2", SymbolInfo::SymbolKind::EnumConstantDecl, HeaderName,
                  {{SymbolInfo::ContextType::EnumDecl, "Glob_E"}});
-  EXPECT_TRUE(hasSymbol(Symbol));
-  EXPECT_TRUE(hasUse(Symbol));
+  EXPECT_EQ(1, seen(Symbol));
+  EXPECT_EQ(1, used(Symbol));
 
-  Symbol = SymbolInfo("Altitude", SymbolInfo::SymbolKind::EnumDecl, HeaderName,
-                      3, {});
-  EXPECT_TRUE(hasSymbol(Symbol));
-  EXPECT_TRUE(hasUse(Symbol));
+  Symbol =
+      SymbolInfo("Altitude", SymbolInfo::SymbolKind::EnumDecl, HeaderName, {});
+  EXPECT_EQ(1, seen(Symbol));
+  EXPECT_EQ(1, used(Symbol));
   Symbol =
       SymbolInfo("high", SymbolInfo::SymbolKind::EnumConstantDecl, HeaderName,
-                 3, {{SymbolInfo::ContextType::EnumDecl, "Altitude"}});
-  EXPECT_FALSE(hasSymbol(Symbol));
-  EXPECT_FALSE(hasUse(Symbol));
+                 {{SymbolInfo::ContextType::EnumDecl, "Altitude"}});
+  EXPECT_EQ(0, seen(Symbol));
+  EXPECT_EQ(0, used(Symbol));
 
   Symbol = SymbolInfo("A1", SymbolInfo::SymbolKind::EnumConstantDecl,
-                      HeaderName, 4, {{SymbolInfo::ContextType::EnumDecl, ""}});
-  EXPECT_TRUE(hasSymbol(Symbol));
-  EXPECT_TRUE(hasUse(Symbol));
+                      HeaderName, {{SymbolInfo::ContextType::EnumDecl, ""}});
+  EXPECT_EQ(1, seen(Symbol));
+  EXPECT_EQ(1, used(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));
+                      HeaderName, {{SymbolInfo::ContextType::EnumDecl, ""}});
+  EXPECT_EQ(1, seen(Symbol));
+  EXPECT_EQ(1, used(Symbol));
+  Symbol = SymbolInfo("", SymbolInfo::SymbolKind::EnumDecl, HeaderName, {});
+  EXPECT_EQ(0, seen(Symbol));
+  EXPECT_EQ(0, used(Symbol));
 
-  Symbol = SymbolInfo("A_ENUM", SymbolInfo::SymbolKind::EnumDecl, HeaderName, 7,
+  Symbol = SymbolInfo("A_ENUM", SymbolInfo::SymbolKind::EnumDecl, HeaderName,
                       {{SymbolInfo::ContextType::Record, "A"}});
-  EXPECT_FALSE(hasSymbol(Symbol));
-  EXPECT_FALSE(hasUse(Symbol));
+  EXPECT_EQ(0, seen(Symbol));
+  EXPECT_EQ(0, used(Symbol));
 
-  Symbol = SymbolInfo("X1", SymbolInfo::SymbolKind::EnumDecl, HeaderName, 7,
+  Symbol = SymbolInfo("X1", SymbolInfo::SymbolKind::EnumDecl, HeaderName,
                       {{SymbolInfo::ContextType::EnumDecl, "A_ENUM"},
                        {SymbolInfo::ContextType::Record, "A"}});
-  EXPECT_FALSE(hasSymbol(Symbol));
+  EXPECT_EQ(0, seen(Symbol));
 
-  Symbol =
-      SymbolInfo("DECL", SymbolInfo::SymbolKind::EnumDecl, HeaderName, 9, {});
-  EXPECT_FALSE(hasSymbol(Symbol));
+  Symbol = SymbolInfo("DECL", SymbolInfo::SymbolKind::EnumDecl, HeaderName, {});
+  EXPECT_EQ(0, seen(Symbol));
 }
 
 TEST_F(FindAllSymbolsTest, IWYUPrivatePragmaTest) {
   static const char Header[] = R"(
     // IWYU pragma: private, include "bar.h"
     struct Bar {
     };
   )";
   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));
+      SymbolInfo("Bar", SymbolInfo::SymbolKind::Class, "bar.h", {});
+  EXPECT_EQ(1, seen(Symbol));
+  EXPECT_EQ(1, used(Symbol));
 }
 
 TEST_F(FindAllSymbolsTest, MacroTest) {
   static const char Header[] = R"(
     #define X
     #define Y 1
     #define MAX(X, Y) ((X) > (Y) ? (X) : (Y))
   )";
   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));
+      SymbolInfo("X", SymbolInfo::SymbolKind::Macro, HeaderName, {});
+  EXPECT_EQ(1, seen(Symbol));
+  EXPECT_EQ(1, used(Symbol));
+
+  Symbol = SymbolInfo("Y", SymbolInfo::SymbolKind::Macro, HeaderName, {});
+  EXPECT_EQ(1, seen(Symbol));
+  EXPECT_EQ(1, used(Symbol));
+
+  Symbol = SymbolInfo("MAX", SymbolInfo::SymbolKind::Macro, HeaderName, {});
+  EXPECT_EQ(1, seen(Symbol));
+  EXPECT_EQ(1, used(Symbol));
 }
 
 TEST_F(FindAllSymbolsTest, MacroTestWithIWYU) {
   static const char Header[] = R"(
     // IWYU pragma: private, include "bar.h"
     #define X 1
     #define Y 1
     #define MAX(X, Y) ((X) > (Y) ? (X) : (Y))
   )";
   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));
+      SymbolInfo("X", SymbolInfo::SymbolKind::Macro, "bar.h", {});
+  EXPECT_EQ(1, seen(Symbol));
+  EXPECT_EQ(1, used(Symbol));
+
+  Symbol = SymbolInfo("Y", SymbolInfo::SymbolKind::Macro, "bar.h", {});
+  EXPECT_EQ(1, seen(Symbol));
+  EXPECT_EQ(1, used(Symbol));
+
+  Symbol = SymbolInfo("MAX", SymbolInfo::SymbolKind::Macro, "bar.h", {});
+  EXPECT_EQ(1, seen(Symbol));
+  EXPECT_EQ(1, used(Symbol));
 }
 
 TEST_F(FindAllSymbolsTest, NoFriendTest) {
   static const char Header[] = R"(
     class WorstFriend {
       friend void Friend();
       friend class BestFriend;
     };
   )";
   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));
+  SymbolInfo Symbol =
+      SymbolInfo("WorstFriend", SymbolInfo::SymbolKind::Class, HeaderName, {});
+  EXPECT_EQ(1, seen(Symbol));
+
+  Symbol =
+      SymbolInfo("Friend", SymbolInfo::SymbolKind::Function, HeaderName, {});
+  EXPECT_EQ(0, seen(Symbol));
+
+  Symbol =
+      SymbolInfo("BestFriend", SymbolInfo::SymbolKind::Class, HeaderName, {});
+  EXPECT_EQ(0, seen(Symbol));
 }
 
 } // namespace find_all_symbols
 } // namespace clang