[include-fixer] Simplify unittest code.

[hokein]

Summary

The InMemorySymbolIndex only constructs hard-coded Class symbols from a string
map. The patch provide a flexable way in InMemorySymbolIndex to create a custom
SymbolInfo in the include-fixer unittest.

[hokein]

Fix a nit.

[hokein]

Fix code style.

[bkramer]

What's a flexable (in the description)? Code LG.

[hokein]

In D20232#429348, @bkramer wrote:

What's a flexable (in the description)? Code LG.

I updated the description now.

[bkramer]

So s/flexable/flexible/ and commit :)

[hokein]

Fix clang-include-fixer build.

clang-tools-extra/trunk/include-fixer/InMemorySymbolIndex.h

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

clang-tools-extra/trunk/include-fixer/InMemorySymbolIndex.cpp

 #include "InMemorySymbolIndex.h"
 
 using clang::find_all_symbols::SymbolInfo;
 
 namespace clang {
 namespace include_fixer {
 
 InMemorySymbolIndex::InMemorySymbolIndex(
-    const std::map<std::string, std::vector<std::string>> &LookupTable) {
-  for (const auto &Entry : LookupTable) {
-    llvm::StringRef Identifier(Entry.first);
-    llvm::SmallVector<llvm::StringRef, 8> Names;
-    Identifier.split(Names, "::");
-    for (const auto &Header : Entry.second) {
-      std::vector<SymbolInfo::Context> Contexts;
-      for (auto IdentiferContext = Names.rbegin() + 1;
-           IdentiferContext != Names.rend(); ++IdentiferContext) {
-        Contexts.emplace_back(SymbolInfo::ContextType::Namespace,
-                              *IdentiferContext);
-      }
-
-      SymbolInfo Symbol(Names.back(), SymbolInfo::SymbolKind::Class, Header,
-                        Contexts, 1);
-      this->LookupTable[Symbol.getName()].push_back(Symbol);
-    }
-  }
+    const std::vector<SymbolInfo> &Symbols) {
+  for (const auto &Symbol : Symbols)
+    LookupTable[Symbol.getName()].push_back(Symbol);
 }
 
 std::vector<SymbolInfo>
 InMemorySymbolIndex::search(llvm::StringRef Identifier) {
   auto I = LookupTable.find(Identifier);
   if (I != LookupTable.end())
     return I->second;
   return {};
 }
 
 } // namespace include_fixer
 } // namespace clang

clang-tools-extra/trunk/include-fixer/find-all-symbols/FindAllSymbols.cpp

llvm::errs() << "Declaration " << ND->getNameAsString() << "("
                  << ") has invalid declaration location.";
     return llvm::None;
   }
   llvm::StringRef FilePath = SM.getFilename(Loc);
   if (FilePath.empty())
     return llvm::None;
 
   return SymbolInfo(ND->getNameAsString(), Type, FilePath.str(),
-                    GetContexts(ND), SM.getExpansionLineNumber(Loc));
+                    SM.getExpansionLineNumber(Loc), GetContexts(ND));
 }
 
 } // namespace
 
 void FindAllSymbols::registerMatchers(MatchFinder *MatchFinder) {
   // FIXME: Handle specialization.
   auto IsInSpecialization = hasAncestor(
       decl(anyOf(cxxRecordDecl(isExplicitTemplateSpecialization()),

clang-tools-extra/trunk/include-fixer/find-all-symbols/SymbolInfo.h

public:
   /// \brief A pair of <ContextType, ContextName>.
   typedef std::pair<ContextType, std::string> Context;
 
   // 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,
-             const std::vector<Context> &Contexts, int LineNumber);
+             int LineNumber, const std::vector<Context> &Contexts);
 
   /// \brief Get symbol name.
   llvm::StringRef getName() const;
 
   /// \brief Get symbol type.
   SymbolKind getSymbolKind() const;
 
   /// \brief Get a relative file path where symbol comes from.

clang-tools-extra/trunk/include-fixer/find-all-symbols/SymbolInfo.cpp

 
 } // namespace yaml
 } // namespace llvm
 
 namespace clang {
 namespace find_all_symbols {
 
 SymbolInfo::SymbolInfo(llvm::StringRef Name, SymbolKind Type,
-                       llvm::StringRef FilePath,
-                       const std::vector<Context> &Contexts, int LineNumber)
+                       llvm::StringRef FilePath, int LineNumber,
+                       const std::vector<Context> &Contexts)
     : Name(Name), Type(Type), FilePath(FilePath), Contexts(Contexts),
       LineNumber(LineNumber) {}
 
 llvm::StringRef SymbolInfo::getName() const { return Name; }
 
 SymbolKind SymbolInfo::getSymbolKind() const { return Type; }
 
 llvm::StringRef SymbolInfo::getFilePath() const { return FilePath; }

clang-tools-extra/trunk/include-fixer/tool/ClangIncludeFixer.cpp

int includeFixerMain(int argc, const char **argv) {
   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;
     for (StringRef Pair : SemicolonSplits) {
       auto Split = Pair.split('=');
       std::vector<std::string> Headers;
       SmallVector<StringRef, 4> CommaSplits;
       Split.second.split(CommaSplits, ",");
       for (StringRef Header : CommaSplits)
-        Headers.push_back(Header.trim());
-      SymbolsMap[Split.first.trim()] = std::move(Headers);
+        Symbols.push_back(find_all_symbols::SymbolInfo(
+            Split.first.trim(),
+            find_all_symbols::SymbolInfo::SymbolKind::Unknown, Header.trim(), 1,
+            {}));
     }
     SymbolIndexMgr->addSymbolIndex(
-        llvm::make_unique<include_fixer::InMemorySymbolIndex>(
-            std::move(SymbolsMap)));
+        llvm::make_unique<include_fixer::InMemorySymbolIndex>(Symbols));
     break;
   }
   case yaml: {
     llvm::ErrorOr<std::unique_ptr<include_fixer::YamlSymbolIndex>> DB(nullptr);
     if (!Input.empty()) {
       DB = include_fixer::YamlSymbolIndex::createFromFile(Input);
     } else {
       // If we don't have any input file, look in the directory of the first

clang-tools-extra/trunk/unittests/include-fixer/IncludeFixerTest.cpp

 //===-- IncludeFixerTest.cpp - Include fixer unit tests -------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "InMemorySymbolIndex.h"
 #include "IncludeFixer.h"
 #include "SymbolIndexManager.h"
 #include "unittests/Tooling/RewriterTestContext.h"
 #include "clang/Tooling/Tooling.h"
 #include "gtest/gtest.h"
-using namespace clang;
 
 namespace clang {
 namespace include_fixer {
 namespace {
 
+using find_all_symbols::SymbolInfo;
+
 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));
   std::vector<std::string> Args = {"include_fixer", "-fsyntax-only", FileName};
static bool runOnCode(tooling::ToolAction *ToolAction, StringRef Code,
   InMemoryFileSystem->addFile("dir/otherdir/qux.h", 0,
                               llvm::MemoryBuffer::getMemBuffer("\n"));
   return Invocation.run();
 }
 
 static std::string runIncludeFixer(
     StringRef Code,
     const std::vector<std::string> &ExtraArgs = std::vector<std::string>()) {
-  std::map<std::string, std::vector<std::string>> SymbolsMap = {
-      {"std::string", {"<string>"}},
-      {"std::sting", {"\"sting\""}},
-      {"std::string::size_type", {"<string>"}},
-      {"a::b::foo", {"dir/otherdir/qux.h"}},
+  std::vector<SymbolInfo> Symbols = {
+      SymbolInfo("string", SymbolInfo::SymbolKind::Class, "<string>", 1,
+                 {{SymbolInfo::ContextType::Namespace, "std"}}),
+      SymbolInfo("sting", SymbolInfo::SymbolKind::Class, "\"sting\"", 1,
+                 {{SymbolInfo::ContextType::Namespace, "std"}}),
+      SymbolInfo("size_type", SymbolInfo::SymbolKind::Variable, "<string>", 1,
+                 {{SymbolInfo::ContextType::Namespace, "string"},
+                  {SymbolInfo::ContextType::Namespace, "std"}}),
+      SymbolInfo("foo", SymbolInfo::SymbolKind::Class, "\"dir/otherdir/qux.h\"",
+                 1, {{SymbolInfo::ContextType::Namespace, "b"},
+                     {SymbolInfo::ContextType::Namespace, "a"}}),
   };
   auto SymbolIndexMgr = llvm::make_unique<include_fixer::SymbolIndexManager>();
   SymbolIndexMgr->addSymbolIndex(
-      llvm::make_unique<include_fixer::InMemorySymbolIndex>(
-          std::move(SymbolsMap)));
+      llvm::make_unique<include_fixer::InMemorySymbolIndex>(Symbols));
 
   std::vector<clang::tooling::Replacement> Replacements;
   IncludeFixerActionFactory Factory(*SymbolIndexMgr, Replacements);
   runOnCode(&Factory, Code, "input.cc", ExtraArgs);
   clang::RewriterTestContext Context;
   clang::FileID ID = Context.createInMemoryFile("input.cc", Code);
   clang::tooling::applyAllReplacements(Replacements, Context.Rewrite);
   return Context.getRewrittenText(ID);

clang-tools-extra/trunk/unittests/include-fixer/find-all-symbols/FindAllSymbolsTests.cpp

bool runFindAllSymbols(StringRef Code) {
     Invocation.run();
     return true;
   }
 
 private:
   MockReporter Reporter;
 };
 
-SymbolInfo CreateSymbolInfo(StringRef Name, SymbolInfo::SymbolKind Type,
-                            StringRef FilePath, int LineNumber,
-                            const std::vector<SymbolInfo::Context> &Contexts) {
-  return SymbolInfo(Name, Type, FilePath, Contexts, LineNumber);
-}
-
 TEST_F(FindAllSymbolsTest, VariableSymbols) {
   static const char Code[] = R"(
       extern int xargc;
       namespace na {
       static bool SSSS = false;
       namespace nb { const long long *XXXX; }
       })";
   runFindAllSymbols(Code);
 
-  SymbolInfo Symbol = CreateSymbolInfo(
-      "xargc", SymbolInfo::SymbolKind::Variable, HeaderName, 2, {});
+  SymbolInfo Symbol =
+      SymbolInfo("xargc", SymbolInfo::SymbolKind::Variable, HeaderName, 2, {});
   EXPECT_TRUE(hasSymbol(Symbol));
 
-  Symbol =
-      CreateSymbolInfo("SSSS", SymbolInfo::SymbolKind::Variable, HeaderName, 4,
-                       {{SymbolInfo::ContextType::Namespace, "na"}});
+  Symbol = SymbolInfo("SSSS", SymbolInfo::SymbolKind::Variable, HeaderName, 4,
   EXPECT_TRUE(hasSymbol(Symbol));
 
-  Symbol =
-      CreateSymbolInfo("XXXX", SymbolInfo::SymbolKind::Variable, HeaderName, 5,
-                       {{SymbolInfo::ContextType::Namespace, "nb"},
-                        {SymbolInfo::ContextType::Namespace, "na"}});
+  Symbol = SymbolInfo("XXXX", SymbolInfo::SymbolKind::Variable, HeaderName, 5,
   EXPECT_TRUE(hasSymbol(Symbol));
 }
 
 TEST_F(FindAllSymbolsTest, ExternCSymbols) {
   static const char Code[] = R"(
       extern "C" {
       int C_Func() { return 0; }
       struct C_struct {
         int Member;
       };
       })";
   runFindAllSymbols(Code);
 
-  SymbolInfo Symbol = CreateSymbolInfo(
-      "C_Func", SymbolInfo::SymbolKind::Function, HeaderName, 3, {});
+  SymbolInfo Symbol =
+      SymbolInfo("C_Func", SymbolInfo::SymbolKind::Function, HeaderName, 3, {});
   EXPECT_TRUE(hasSymbol(Symbol));
 
-  Symbol = CreateSymbolInfo("C_struct", SymbolInfo::SymbolKind::Class,
-                            HeaderName, 4, {});
+  Symbol =
+      SymbolInfo("C_struct", SymbolInfo::SymbolKind::Class, HeaderName, 4, {});
   EXPECT_TRUE(hasSymbol(Symbol));
 }
 
 TEST_F(FindAllSymbolsTest, CXXRecordSymbols) {
   static const char Code[] = 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);
 
-  SymbolInfo Symbol = CreateSymbolInfo("Glob", SymbolInfo::SymbolKind::Class,
-                                       HeaderName, 2, {});
+  SymbolInfo Symbol =
+      SymbolInfo("Glob", SymbolInfo::SymbolKind::Class, HeaderName, 2, {});
   EXPECT_TRUE(hasSymbol(Symbol));
 
-  Symbol = CreateSymbolInfo("A", SymbolInfo::SymbolKind::Class, HeaderName, 6,
-                            {{SymbolInfo::ContextType::Namespace, "na"}});
+  Symbol = SymbolInfo("A", SymbolInfo::SymbolKind::Class, HeaderName, 6,
   EXPECT_TRUE(hasSymbol(Symbol));
 
-  Symbol = CreateSymbolInfo("AAA", SymbolInfo::SymbolKind::Class, HeaderName, 7,
-                            {{SymbolInfo::ContextType::Record, "A"},
-                             {SymbolInfo::ContextType::Namespace, "na"}});
+  Symbol = SymbolInfo("AAA", SymbolInfo::SymbolKind::Class, HeaderName, 7,
   EXPECT_FALSE(hasSymbol(Symbol));
 }
 
 TEST_F(FindAllSymbolsTest, CXXRecordSymbolsTemplate) {
   static const char Code[] = R"(
       template <typename T>
       class 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);
 
-  SymbolInfo Symbol = CreateSymbolInfo("T_TEMP", SymbolInfo::SymbolKind::Class,
-                                       HeaderName, 3, {});
+  SymbolInfo Symbol =
+      SymbolInfo("T_TEMP", SymbolInfo::SymbolKind::Class, HeaderName, 3, {});
   EXPECT_TRUE(hasSymbol(Symbol));
 }
 
 TEST_F(FindAllSymbolsTest, FunctionSymbols) {
   static const char Code[] = 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);
 
   SymbolInfo Symbol =
-      CreateSymbolInfo("gg", SymbolInfo::SymbolKind::Function, HeaderName, 3,
-                       {{SymbolInfo::ContextType::Namespace, "na"}});
+      SymbolInfo("gg", SymbolInfo::SymbolKind::Function, HeaderName, 3,
   EXPECT_TRUE(hasSymbol(Symbol));
 
-  Symbol = CreateSymbolInfo("f", SymbolInfo::SymbolKind::Function, HeaderName,
-                            4, {{SymbolInfo::ContextType::Namespace, "na"}});
+  Symbol = SymbolInfo("f", SymbolInfo::SymbolKind::Function, HeaderName, 4,
+                      {{SymbolInfo::ContextType::Namespace, "na"}});
   EXPECT_TRUE(hasSymbol(Symbol));
 
-  Symbol =
-      CreateSymbolInfo("SSSFFF", SymbolInfo::SymbolKind::Function, HeaderName,
-                       5, {{SymbolInfo::ContextType::Namespace, "na"}});
+  Symbol = SymbolInfo("SSSFFF", SymbolInfo::SymbolKind::Function, HeaderName, 5,
+                      {{SymbolInfo::ContextType::Namespace, "na"}});
   EXPECT_TRUE(hasSymbol(Symbol));
 
-  Symbol = CreateSymbolInfo("fun", SymbolInfo::SymbolKind::Function, HeaderName,
-                            10, {{SymbolInfo::ContextType::Namespace, "nb"},
-                                 {SymbolInfo::ContextType::Namespace, "na"}});
+  Symbol = SymbolInfo("fun", SymbolInfo::SymbolKind::Function, HeaderName, 10,
+                      {{SymbolInfo::ContextType::Namespace, "nb"},
   EXPECT_TRUE(hasSymbol(Symbol));
 }
 
 TEST_F(FindAllSymbolsTest, NamespaceTest) {
   static const char Code[] = R"(
       int X1;
       namespace { int X2; }
       namespace { namespace { int X3; } }
       namespace { namespace nb { int X4;} }
       )";
   runFindAllSymbols(Code);
 
-  SymbolInfo Symbol = CreateSymbolInfo("X1", SymbolInfo::SymbolKind::Variable,
-                                       HeaderName, 2, {});
+  SymbolInfo Symbol =
+      SymbolInfo("X1", SymbolInfo::SymbolKind::Variable, HeaderName, 2, {});
   EXPECT_TRUE(hasSymbol(Symbol));
 
-  Symbol = CreateSymbolInfo("X2", SymbolInfo::SymbolKind::Variable, HeaderName,
-                            3, {{SymbolInfo::ContextType::Namespace, ""}});
+  Symbol = SymbolInfo("X2", SymbolInfo::SymbolKind::Variable, HeaderName, 3,
+                      {{SymbolInfo::ContextType::Namespace, ""}});
   EXPECT_TRUE(hasSymbol(Symbol));
 
-  Symbol = CreateSymbolInfo("X3", SymbolInfo::SymbolKind::Variable, HeaderName,
-                            4, {{SymbolInfo::ContextType::Namespace, ""},
-                                {SymbolInfo::ContextType::Namespace, ""}});
+  Symbol = SymbolInfo("X3", SymbolInfo::SymbolKind::Variable, HeaderName, 4,
+                      {{SymbolInfo::ContextType::Namespace, ""},
   EXPECT_TRUE(hasSymbol(Symbol));
 
-  Symbol = CreateSymbolInfo("X4", SymbolInfo::SymbolKind::Variable, HeaderName,
-                            5, {{SymbolInfo::ContextType::Namespace, "nb"},
-                                {SymbolInfo::ContextType::Namespace, ""}});
+  Symbol = SymbolInfo("X4", SymbolInfo::SymbolKind::Variable, HeaderName, 5,
+                      {{SymbolInfo::ContextType::Namespace, "nb"},
   EXPECT_TRUE(hasSymbol(Symbol));
 }
 
 TEST_F(FindAllSymbolsTest, DecayedTypeTest) {
   static const char Code[] = "void DecayedFunc(int x[], int y[10]) {}";
   runFindAllSymbols(Code);
-  SymbolInfo Symbol = CreateSymbolInfo(
+  SymbolInfo Symbol = SymbolInfo(
       "DecayedFunc", SymbolInfo::SymbolKind::Function, HeaderName, 1, {});
   EXPECT_TRUE(hasSymbol(Symbol));
 }
 
 TEST_F(FindAllSymbolsTest, CTypedefTest) {
   static const char Code[] = R"(
       typedef unsigned size_t_;
       typedef struct { int x; } X;
       using XX = X;
       )";
   runFindAllSymbols(Code);
 
-  SymbolInfo Symbol = CreateSymbolInfo(
-      "size_t_", SymbolInfo::SymbolKind::TypedefName, HeaderName, 2, {});
+  SymbolInfo Symbol = SymbolInfo("size_t_", SymbolInfo::SymbolKind::TypedefName,
+                                 HeaderName, 2, {});
   EXPECT_TRUE(hasSymbol(Symbol));
 
-  Symbol = CreateSymbolInfo("X", SymbolInfo::SymbolKind::TypedefName,
-                            HeaderName, 3, {});
+  Symbol =
+      SymbolInfo("X", SymbolInfo::SymbolKind::TypedefName, HeaderName, 3, {});
   EXPECT_TRUE(hasSymbol(Symbol));
 
-  Symbol = CreateSymbolInfo("XX", SymbolInfo::SymbolKind::TypedefName,
-                            HeaderName, 4, {});
+  Symbol =
+      SymbolInfo("XX", SymbolInfo::SymbolKind::TypedefName, HeaderName, 4, {});
   EXPECT_TRUE(hasSymbol(Symbol));
 }
 
 TEST_F(FindAllSymbolsTest, EnumTest) {
   static const char Code[] = R"(
       enum Glob_E { G1, G2 };
       enum class Altitude { high='h', low='l'};
       enum { A1, A2 };
       class A {
       public:
         enum A_ENUM { X1, X2 };
       };
       )";
   runFindAllSymbols(Code);
 
-  SymbolInfo Symbol = CreateSymbolInfo(
-      "Glob_E", SymbolInfo::SymbolKind::EnumDecl, HeaderName, 2, {});
+  SymbolInfo Symbol =
+      SymbolInfo("Glob_E", SymbolInfo::SymbolKind::EnumDecl, HeaderName, 2, {});
   EXPECT_TRUE(hasSymbol(Symbol));
 
-  Symbol = CreateSymbolInfo("G1", SymbolInfo::SymbolKind::EnumConstantDecl,
-                            HeaderName, 2,
-                            {{SymbolInfo::ContextType::EnumDecl, "Glob_E"}});
+  Symbol =
+      SymbolInfo("G1", SymbolInfo::SymbolKind::EnumConstantDecl, HeaderName, 2,
   EXPECT_TRUE(hasSymbol(Symbol));
 
-  Symbol = CreateSymbolInfo("G2", SymbolInfo::SymbolKind::EnumConstantDecl,
-                            HeaderName, 2,
-                            {{SymbolInfo::ContextType::EnumDecl, "Glob_E"}});
+  Symbol =
+      SymbolInfo("G2", SymbolInfo::SymbolKind::EnumConstantDecl, HeaderName, 2,
   EXPECT_TRUE(hasSymbol(Symbol));
 
-  Symbol = CreateSymbolInfo("Altitude", SymbolInfo::SymbolKind::EnumDecl,
-                            HeaderName, 3, {});
+  Symbol = SymbolInfo("Altitude", SymbolInfo::SymbolKind::EnumDecl, HeaderName,
+                      3, {});
   EXPECT_TRUE(hasSymbol(Symbol));
-  Symbol = CreateSymbolInfo("high", SymbolInfo::SymbolKind::EnumConstantDecl,
-                            HeaderName, 3,
-                            {{SymbolInfo::ContextType::EnumDecl, "Altitude"}});
+  Symbol =
+      SymbolInfo("high", SymbolInfo::SymbolKind::EnumConstantDecl, HeaderName,
+                 3, {{SymbolInfo::ContextType::EnumDecl, "Altitude"}});
   EXPECT_FALSE(hasSymbol(Symbol));
 
-  Symbol = CreateSymbolInfo("A1", SymbolInfo::SymbolKind::EnumConstantDecl,
-                            HeaderName, 4,
-                            {{SymbolInfo::ContextType::EnumDecl, ""}});
-  EXPECT_TRUE(hasSymbol(Symbol));
-  Symbol = CreateSymbolInfo("A2", SymbolInfo::SymbolKind::EnumConstantDecl,
-                            HeaderName, 4,
-                            {{SymbolInfo::ContextType::EnumDecl, ""}});
+  Symbol = SymbolInfo("A1", SymbolInfo::SymbolKind::EnumConstantDecl,
+                      HeaderName, 4, {{SymbolInfo::ContextType::EnumDecl, ""}});
+  EXPECT_TRUE(hasSymbol(Symbol));
+  Symbol = SymbolInfo("A2", SymbolInfo::SymbolKind::EnumConstantDecl,
+                      HeaderName, 4, {{SymbolInfo::ContextType::EnumDecl, ""}});
   EXPECT_TRUE(hasSymbol(Symbol));
 
-  Symbol =
-      CreateSymbolInfo("A_ENUM", SymbolInfo::SymbolKind::EnumDecl, HeaderName,
-                       7, {{SymbolInfo::ContextType::Record, "A"}});
+  Symbol = SymbolInfo("A_ENUM", SymbolInfo::SymbolKind::EnumDecl, HeaderName, 7,
+                      {{SymbolInfo::ContextType::Record, "A"}});
   EXPECT_FALSE(hasSymbol(Symbol));
 
-  Symbol = CreateSymbolInfo("X1", SymbolInfo::SymbolKind::EnumDecl, HeaderName,
-                            7, {{SymbolInfo::ContextType::EnumDecl, "A_ENUM"},
-                                {SymbolInfo::ContextType::Record, "A"}});
+  Symbol = SymbolInfo("X1", SymbolInfo::SymbolKind::EnumDecl, HeaderName, 7,
+                      {{SymbolInfo::ContextType::EnumDecl, "A_ENUM"},
   EXPECT_FALSE(hasSymbol(Symbol));
 }
 
 } // namespace find_all_symbols
 } // namespace clang