Added static creators that create complete instances of SymbolInfo.

[ioeric]

Summary

Added static creators that create complete instances of SymbolInfo.

[klimek]

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

98–101

To some degree this looks like we actually want a class hierarchy. But currently only ClassSymbolInfo is used?

[hokein]

Not sure whether this is what @klimek expected..

You also need to update the FindAllSymbolsTests code (there is a CreateSymbolInfo function there).

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

91

code indentation.

105

A extra blank line.

115

The same.

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

99

Use llvm::StringRef instead of std::string&.

[ioeric]

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

98–101

At this point yes, since Symbolnfo is only created in InMemoryXrefsDB and FindAllSymbols now, and it is not trivial to change FindAllSymbols to use these creators.

But one immediate use case I can foresee is converting proto buffer SymbolInfo to clang SymbolInfo when integrating with Google3 XrefsDB.

[klimek]

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

98–101

I think at this point YAGNI applies and we shouldn't create stuff that we don't use yet - code generally starts to rot when it's not used ;)

[ioeric]

Use static creator functions in SymbolInfo in FindAllSymbolTests, and make SymbolInfo::operator== compare all fields.

[ioeric]

• Use static creator functions in SymbolInfo in FindAllSymbolTests, and make SymbolInfo::operator== compare all fields.

[ioeric]

• Use template to compare llvm::Optional<T> types.

[hokein]

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

91–92

You can remove it now.

[ioeric]

• Removed unused function in unit test.

[ioeric]

• Removed SetCommonInfo declaration from header.

[hokein]

It looks good to me now, but need to wait @klimek acceptance.

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

98–101

However, changing SymbolInfo to class requires us to add many setters/getters in it.

Currently the SymbolInfo is like ClangTidyOptions structure.

[klimek]

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

98–101

So, multiple thoughts:

• generally, I think symbol info would better be an immutable type; that would mean that we wouldn't have setters, just getters, and initialize everything in the constructor
• afaik llvm/clang style doesn't require accessors just because something is a class
• I believe ClangTidyOptions is a very different use case

[ioeric]

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

98–101

But this change would also affect the way SymbolInfo is constructed in FindAllSymbol - class members are retrieved from AST in different locations, and we'd need to store fields in many temp variables, which might be troublesome in this case as well as some other cases. With a struct implementation plus static creatrors, we can have some flexibility. But I'm not sure if this makes sense from design perspective.

include-fixer/InMemoryXrefsDB.cpp

 
 InMemoryXrefsDB::InMemoryXrefsDB(
     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) {
-      // FIXME: create a complete instance with static member function when it
-      // is implemented.
-      SymbolInfo Info;
-      Info.Name = Names.back();
-      Info.FilePath = Header;
+      // Since we don't have all symbol information here, we just construct a
+      // dummy SymbolInfo with the given contexts and header path.
+      std::vector<SymbolInfo::Context> Contexts;
       for (auto IdentiferContext = Names.rbegin() + 1;
            IdentiferContext != Names.rend(); ++IdentiferContext) {
-        Info.Contexts.push_back(
+        Contexts.push_back(
             {SymbolInfo::ContextType::Namespace, *IdentiferContext});
       }
+      SymbolInfo Info =
+          SymbolInfo::CreateClassSymbolInfo(Names.back(), Header, Contexts, 1);
+
       this->LookupTable[Info.Name].push_back(Info);
     }
   }
 }
 
 std::vector<SymbolInfo> InMemoryXrefsDB::search(llvm::StringRef Identifier) {
   auto I = LookupTable.find(Identifier);
   if (I != LookupTable.end())
     return I->second;
   return {};
 }
 
 } // namespace include_fixer
 } // namespace clang

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

 #include <set>
 #include <string>
 #include <vector>
 
 namespace clang {
 namespace find_all_symbols {
 
 /// \brief Contains all information for a Symbol.
-// FIXME: add static members for creating complete instances.
 struct SymbolInfo {
   enum SymbolKind {
     Function,
     Class,
     Variable,
     TypedefName,
   };
 
struct SymbolInfo {
   std::vector<Context> Contexts;
 
   /// \brief The 1-based line number of of the symbol's declaration.
   int LineNumber;
 
   struct FunctionInfo {
     std::string ReturnType;
     std::vector<std::string> ParameterTypes;
+    bool operator==(const FunctionInfo &Info) const {
+      return ReturnType == Info.ReturnType &&
+             ParameterTypes == Info.ParameterTypes;
+    }
   };
 
   struct TypedefNameInfo {
     std::string UnderlyingType;
+    bool operator==(const TypedefNameInfo &Info) const {
+      return UnderlyingType == Info.UnderlyingType;
+    }
   };
 
   struct VariableInfo {
     std::string Type;
+    bool operator==(const VariableInfo &Info) const { return Type == Info.Type; }
   };
 
   /// \brief The function information.
   llvm::Optional<FunctionInfo> FunctionInfos;
 
   /// \brief The typedef information.
   llvm::Optional<TypedefNameInfo> TypedefNameInfos;
 
   /// \brief The variable information.
   llvm::Optional<VariableInfo> VariableInfos;
 
   bool operator==(const SymbolInfo &Symbol) const;
 
   bool operator<(const SymbolInfo &Symbol) const;
+
+  static SymbolInfo
+  CreateFunctionSymbolInfo(const std::string &Name, const std::string &FilePath,
+                           const std::vector<Context> &Contexts, int LineNumber,
+                           const FunctionInfo &FuncInfo);
+
+  static SymbolInfo CreateClassSymbolInfo(const std::string &Name,
+                                          const std::string &FilePath,
+                                          const std::vector<Context> &Contexts,
+                                          int LineNumber);
+
+  static SymbolInfo
+  CreateVariableSymbolInfo(const std::string &Name, const std::string &FilePath,
+                           const std::vector<Context> &Contexts, int LineNumber,
+                           const VariableInfo &VarInfo);
+
+  static SymbolInfo
+  CreateTypedefNameSymbolInfo(const std::string &Name,
+                              const std::string &FilePath,
+                              const std::vector<Context> &Contexts,
+                              int LineNumber, const TypedefNameInfo &TDInfo);
 };
 
 /// \brief Write SymbolInfos to a stream (YAML format).
 bool WriteSymbolInfosToStream(llvm::raw_ostream &OS,
                               const std::set<SymbolInfo> &Symbols);
 
 /// \brief Read SymbolInfos from a YAML document.
 std::vector<SymbolInfo> ReadSymbolInfosFromYAML(llvm::StringRef Yaml);
 
 } // namespace find_all_symbols
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_INCLUDE_FIXER_FIND_ALL_SYMBOLS_SYMBOL_INFO_H

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

 };
 
 } // namespace yaml
 } // namespace llvm
 
 namespace clang {
 namespace find_all_symbols {
 
+static void SetCommonInfo(const std::string &Name, SymbolKind Kind,
+                          const std::string &FilePath,
+                          const std::vector<SymbolInfo::Context> &Contexts,
+                          int LineNumber, SymbolInfo *Info) {
+  Info->Name = Name;
+  Info->Type = Kind;
+  Info->FilePath = FilePath;
+  Info->Contexts = Contexts;
+  Info->LineNumber = LineNumber;
+}
+
+SymbolInfo SymbolInfo::CreateFunctionSymbolInfo(
+    const std::string &Name, const std::string &FilePath,
+    const std::vector<Context> &Contexts, int LineNumber,
+    const FunctionInfo &FuncInfo) {
+  SymbolInfo Ret;
+  SetCommonInfo(Name, Function, FilePath, Contexts, LineNumber, &Ret);
+  Ret.FunctionInfos = FuncInfo;
+  return Ret;
+}
+
+SymbolInfo SymbolInfo::CreateClassSymbolInfo(
+    const std::string &Name, const std::string &FilePath,
+    const std::vector<Context> &Contexts, int LineNumber) {
+  SymbolInfo Ret;
+  SetCommonInfo(Name, Class, FilePath, Contexts, LineNumber, &Ret);
+  return Ret;
+}
+
+SymbolInfo SymbolInfo::CreateVariableSymbolInfo(
+    const std::string &Name, const std::string &FilePath,
+    const std::vector<Context> &Contexts, int LineNumber,
+    const VariableInfo &VarInfo) {
+  SymbolInfo Ret;
+  SetCommonInfo(Name, Variable, FilePath, Contexts, LineNumber, &Ret);
+  Ret.VariableInfos = VarInfo;
+  return Ret;
+}
+
+SymbolInfo SymbolInfo::CreateTypedefNameSymbolInfo(
+    const std::string &Name, const std::string &FilePath,
+    const std::vector<Context> &Contexts, int LineNumber,
+    const TypedefNameInfo &TDInfo) {
+  SymbolInfo Ret;
+  SetCommonInfo(Name, TypedefName, FilePath, Contexts, LineNumber, &Ret);
+  Ret.TypedefNameInfos = TDInfo;
+  return Ret;
+}
+
+template <typename T>
+static bool CompareOptionalInfo(const llvm::Optional<T> &LHS,
+                                const llvm::Optional<T> &RHS) {
+  return (!LHS.hasValue() && !RHS.hasValue()) ||
+         (LHS.hasValue() && RHS.hasValue() && LHS.getValue() == RHS.getValue());
+}
+
 bool SymbolInfo::operator==(const SymbolInfo &Symbol) const {
-  return Name == Symbol.Name && FilePath == Symbol.FilePath &&
-         LineNumber == Symbol.LineNumber && Contexts == Symbol.Contexts;
+  return Type == Symbol.Type && Name == Symbol.Name &&
+         FilePath == Symbol.FilePath && LineNumber == Symbol.LineNumber &&
+         Contexts == Symbol.Contexts &&
+         CompareOptionalInfo(FunctionInfos, Symbol.FunctionInfos) &&
+         CompareOptionalInfo(TypedefNameInfos, Symbol.TypedefNameInfos) &&
+         CompareOptionalInfo(VariableInfos, Symbol.VariableInfos);
 }
 
 bool SymbolInfo::operator<(const SymbolInfo &Symbol) const {
   return std::tie(Name, FilePath, LineNumber) <
          std::tie(Symbol.Name, Symbol.FilePath, Symbol.LineNumber);
 }
 
 bool WriteSymbolInfosToStream(llvm::raw_ostream &OS,

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

public:
   bool hasSymbol(const SymbolInfo &Symbol) {
     for (const auto &S : Symbols) {
       if (S == Symbol)
         return true;
     }
     return false;
   }
 
-  bool getSymbolExtraInfo(SymbolInfo *Symbol) {
-    for (const auto &S : Symbols) {
-      if (S == *Symbol) {
-        Symbol->FunctionInfos = S.FunctionInfos;
-        Symbol->TypedefNameInfos = S.TypedefNameInfos;
-        Symbol->VariableInfos = S.VariableInfos;
-        return true;
-      }
-    }
-    return false;
-  }
-
 private:
   std::vector<SymbolInfo> Symbols;
 };
 
 class FindAllSymbolsTest : public ::testing::Test {
 public:
   bool hasSymbol(const SymbolInfo &Symbol) {
     return Reporter.hasSymbol(Symbol);
   }
 
-  bool getSymbolExtraInfo(SymbolInfo &Symbol) {
-    return Reporter.getSymbolExtraInfo(&Symbol);
-  }
-
   bool runFindAllSymbols(StringRef Code) {
     FindAllSymbols matcher(&Reporter);
     clang::ast_matchers::MatchFinder MatchFinder;
     matcher.registerMatchers(&MatchFinder);
 
     llvm::IntrusiveRefCntPtr<vfs::InMemoryFileSystem> InMemoryFileSystem(
         new vfs::InMemoryFileSystem);
     llvm::IntrusiveRefCntPtr<FileManager> Files(
         new FileManager(FileSystemOptions(), InMemoryFileSystem));
 
     std::string FileName = "symbol.cc";
     std::unique_ptr<clang::tooling::FrontendActionFactory> Factory =
         clang::tooling::newFrontendActionFactory(&MatchFinder);
     tooling::ToolInvocation Invocation(
         {std::string("find_all_symbols"), std::string("-fsyntax-only"),
-         FileName},
+         std::string("-std=c++11"), FileName},
         Factory->create(), Files.get(),
         std::make_shared<PCHContainerOperations>());
 
     InMemoryFileSystem->addFile(HeaderName, 0,
                                 llvm::MemoryBuffer::getMemBuffer(Code));
 
     std::string Content = "#include\"" + std::string(HeaderName) + "\"";
     InMemoryFileSystem->addFile(FileName, 0,
                                 llvm::MemoryBuffer::getMemBuffer(Content));
     Invocation.run();
     return true;
   }
 
 private:
   MockReporter Reporter;
 };
 
-SymbolInfo
-CreateSymbolInfo(StringRef Name, SymbolInfo::SymbolKind Type,
-                 const std::string FilePath, int LineNumber,
-                 const std::vector<SymbolInfo::Context> &Contexts) {
-  SymbolInfo Symbol;
-  Symbol.Name = Name;
-  Symbol.Type = Type;
-  Symbol.FilePath = FilePath;
-  Symbol.LineNumber = LineNumber;
-  Symbol.Contexts = Contexts;
-  return Symbol;
-}
-
 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::Variable, HeaderName, 2, {});
-    EXPECT_TRUE(hasSymbol(Symbol));
-    getSymbolExtraInfo(Symbol);
-    EXPECT_EQ("int", Symbol.VariableInfos.getValue().Type);
-  }
-  {
-    SymbolInfo Symbol =
-        CreateSymbolInfo("SSSS", SymbolInfo::Variable, HeaderName, 4,
-                         {{SymbolInfo::Namespace, "na"}});
-    EXPECT_TRUE(hasSymbol(Symbol));
-    getSymbolExtraInfo(Symbol);
-    EXPECT_EQ("_Bool", Symbol.VariableInfos.getValue().Type);
-  }
-  {
-    SymbolInfo Symbol = CreateSymbolInfo(
-        "XXXX", SymbolInfo::Variable, HeaderName, 5,
-        {{SymbolInfo::Namespace, "nb"}, {SymbolInfo::Namespace, "na"}});
-    EXPECT_TRUE(hasSymbol(Symbol));
-    getSymbolExtraInfo(Symbol);
-    EXPECT_EQ("const long long *", Symbol.VariableInfos.getValue().Type);
-  }
+      SymbolInfo::CreateVariableSymbolInfo("xargc", HeaderName, {}, 2, {"int"});
+
+  Symbol = SymbolInfo::CreateVariableSymbolInfo(
+      "SSSS", HeaderName, {{SymbolInfo::Namespace, "na"}}, 4, {"_Bool"});
+
+  Symbol = SymbolInfo::CreateVariableSymbolInfo(
+      "XXXX", HeaderName,
+      {{SymbolInfo::Namespace, "nb"}, {SymbolInfo::Namespace, "na"}}, 5,
+      {"const long long *"});
 }
 
 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::Function, HeaderName, 3, {});
-    EXPECT_TRUE(hasSymbol(Symbol));
-    getSymbolExtraInfo(Symbol);
-    EXPECT_EQ("int", Symbol.FunctionInfos.getValue().ReturnType);
-    EXPECT_TRUE(Symbol.FunctionInfos.getValue().ParameterTypes.empty());
-  }
-  {
-    SymbolInfo Symbol =
-        CreateSymbolInfo("C_struct", SymbolInfo::Class, HeaderName, 4, {});
-    EXPECT_TRUE(hasSymbol(Symbol));
-  }
-}
+  SymbolInfo Symbol = SymbolInfo::CreateFunctionSymbolInfo("C_Func", HeaderName,
+                                                           {}, 3, {"int", {}});
+
+  Symbol = SymbolInfo::CreateClassSymbolInfo("C_struct", HeaderName, {}, 4);
 
 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::Class, HeaderName, 2, {});
-    EXPECT_TRUE(hasSymbol(Symbol));
-  }
-  {
-    SymbolInfo Symbol = CreateSymbolInfo("A", SymbolInfo::Class, HeaderName, 6,
-                                         {{SymbolInfo::Namespace, "na"}});
-    EXPECT_TRUE(hasSymbol(Symbol));
-  }
-}
+      SymbolInfo::CreateClassSymbolInfo("Glob", HeaderName, {}, 2);
+  Symbol = SymbolInfo::CreateClassSymbolInfo(
+      "A", HeaderName, {{SymbolInfo::Namespace, "na"}}, 6);
 
 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::Class, HeaderName, 3, {});
-    EXPECT_TRUE(hasSymbol(Symbol));
-  }
-}
+      SymbolInfo::CreateClassSymbolInfo("T_TEMP", HeaderName, {}, 3);
 
 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::Class, HeaderName, 3,
-                                         {{SymbolInfo::Namespace, "na"}});
-    EXPECT_TRUE(hasSymbol(Symbol));
-    getSymbolExtraInfo(Symbol);
-    EXPECT_EQ("int", Symbol.FunctionInfos.getValue().ReturnType);
-    EXPECT_EQ(1u, Symbol.FunctionInfos.getValue().ParameterTypes.size());
-    EXPECT_EQ("int", Symbol.FunctionInfos.getValue().ParameterTypes[0]);
-  }
-  {
-    SymbolInfo Symbol = CreateSymbolInfo("f", SymbolInfo::Class, HeaderName, 4,
-                                         {{SymbolInfo::Namespace, "na"}});
-    EXPECT_TRUE(hasSymbol(Symbol));
-    getSymbolExtraInfo(Symbol);
-    EXPECT_EQ("int", Symbol.FunctionInfos.getValue().ReturnType);
-    EXPECT_EQ(1u, Symbol.FunctionInfos.getValue().ParameterTypes.size());
-    EXPECT_EQ("const int &", Symbol.FunctionInfos.getValue().ParameterTypes[0]);
-  }
-  {
-    SymbolInfo Symbol =
-        CreateSymbolInfo("SSSFFF", SymbolInfo::Class, HeaderName, 5,
-                         {{SymbolInfo::Namespace, "na"}});
-    EXPECT_TRUE(hasSymbol(Symbol));
-    getSymbolExtraInfo(Symbol);
-    EXPECT_EQ("void", Symbol.FunctionInfos.getValue().ReturnType);
-    EXPECT_TRUE(Symbol.FunctionInfos.getValue().ParameterTypes.empty());
-  }
-  {
-    SymbolInfo Symbol = CreateSymbolInfo(
-        "fun", SymbolInfo::Class, HeaderName, 10,
-        {{SymbolInfo::Namespace, "nb"}, {SymbolInfo::Namespace, "na"}});
-    EXPECT_TRUE(hasSymbol(Symbol));
-    getSymbolExtraInfo(Symbol);
-    EXPECT_EQ("void", Symbol.FunctionInfos.getValue().ReturnType);
-    EXPECT_EQ(1u, Symbol.FunctionInfos.getValue().ParameterTypes.size());
-    EXPECT_EQ("T", Symbol.FunctionInfos.getValue().ParameterTypes[0]);
-  }
+  SymbolInfo Symbol = SymbolInfo::CreateFunctionSymbolInfo(
+      "gg", HeaderName, {{SymbolInfo::Namespace, "na"}}, 3, {"int", {"int"}});
+  EXPECT_TRUE(hasSymbol(Symbol));
+
+  Symbol = SymbolInfo::CreateFunctionSymbolInfo("f", HeaderName,
+                                                {{SymbolInfo::Namespace, "na"}},
+                                                4, {"int", {"const int &"}});
+  EXPECT_TRUE(hasSymbol(Symbol));
+
+  Symbol = SymbolInfo::CreateFunctionSymbolInfo(
+      "SSSFFF", HeaderName, {{SymbolInfo::Namespace, "na"}}, 5, {"void", {}});
+  EXPECT_TRUE(hasSymbol(Symbol));
+
+  Symbol = SymbolInfo::CreateFunctionSymbolInfo(
+      "fun", HeaderName,
+      {{SymbolInfo::Namespace, "nb"}, {SymbolInfo::Namespace, "na"}}, 10,
+      {"void", {"T"}});
 }
 
 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::Variable, HeaderName, 2, {});
-    EXPECT_TRUE(hasSymbol(Symbol));
-    getSymbolExtraInfo(Symbol);
-    EXPECT_EQ("int", Symbol.VariableInfos.getValue().Type);
-  }
-  {
-    SymbolInfo Symbol = CreateSymbolInfo("X2", SymbolInfo::Variable, HeaderName,
-                                         3, {{SymbolInfo::Namespace, ""}});
-    EXPECT_TRUE(hasSymbol(Symbol));
-    getSymbolExtraInfo(Symbol);
-    EXPECT_EQ("int", Symbol.VariableInfos.getValue().Type);
-  }
-  {
-    SymbolInfo Symbol = CreateSymbolInfo(
-        "X3", SymbolInfo::Variable, HeaderName, 4,
-        {{SymbolInfo::Namespace, ""}, {SymbolInfo::Namespace, ""}});
-    EXPECT_TRUE(hasSymbol(Symbol));
-    getSymbolExtraInfo(Symbol);
-    EXPECT_EQ("int", Symbol.VariableInfos.getValue().Type);
-  }
-  {
-    SymbolInfo Symbol = CreateSymbolInfo(
-        "X4", SymbolInfo::Variable, HeaderName, 5,
-        {{SymbolInfo::Namespace, "nb"}, {SymbolInfo::Namespace, ""}});
-    EXPECT_TRUE(hasSymbol(Symbol));
-    getSymbolExtraInfo(Symbol);
-    EXPECT_EQ("int", Symbol.VariableInfos.getValue().Type);
-  }
+      SymbolInfo::CreateVariableSymbolInfo("X1", HeaderName, {}, 2, {"int"});
+
+  Symbol = SymbolInfo::CreateVariableSymbolInfo(
+      "X2", HeaderName, {{SymbolInfo::Namespace, ""}}, 3, {"int"});
+
+  Symbol = SymbolInfo::CreateVariableSymbolInfo(
+      "X3", HeaderName,
+      {{SymbolInfo::Namespace, ""}, {SymbolInfo::Namespace, ""}}, 4, {"int"});
+
+  Symbol = SymbolInfo::CreateVariableSymbolInfo(
+      "X4", HeaderName,
+      {{SymbolInfo::Namespace, "nb"}, {SymbolInfo::Namespace, ""}}, 5, {"int"});
 }
 
 TEST_F(FindAllSymbolsTest, DecayedTypeTest) {
   static const char Code[] = "void DecayedFunc(int x[], int y[10]) {}";
   runFindAllSymbols(Code);
-  SymbolInfo Symbol =
-      CreateSymbolInfo("DecayedFunc", SymbolInfo::Class, HeaderName, 1, {});
+  SymbolInfo Symbol = SymbolInfo::CreateFunctionSymbolInfo(
+      "DecayedFunc", HeaderName, {}, 1, {"void", {"int *", "int *"}});
   EXPECT_TRUE(hasSymbol(Symbol));
-  getSymbolExtraInfo(Symbol);
-  EXPECT_EQ("void", Symbol.FunctionInfos.getValue().ReturnType);
-  EXPECT_EQ(2u, Symbol.FunctionInfos.getValue().ParameterTypes.size());
-  EXPECT_EQ("int *", Symbol.FunctionInfos.getValue().ParameterTypes[0]);
-  EXPECT_EQ("int *", Symbol.FunctionInfos.getValue().ParameterTypes[1]);
 }
 
 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::TypedefName, HeaderName, 2, {});
-    EXPECT_TRUE(hasSymbol(Symbol));
-    getSymbolExtraInfo(Symbol);
-    EXPECT_EQ("unsigned int",
-              Symbol.TypedefNameInfos.getValue().UnderlyingType);
-  }
-  {
-    SymbolInfo Symbol =
-        CreateSymbolInfo("X", SymbolInfo::TypedefName, HeaderName, 3, {});
-    EXPECT_TRUE(hasSymbol(Symbol));
-    getSymbolExtraInfo(Symbol);
-    EXPECT_EQ("struct X", Symbol.TypedefNameInfos.getValue().UnderlyingType);
-  }
-  {
-    SymbolInfo Symbol =
-        CreateSymbolInfo("XX", SymbolInfo::TypedefName, HeaderName, 4, {});
-    EXPECT_TRUE(hasSymbol(Symbol));
-    getSymbolExtraInfo(Symbol);
-    EXPECT_EQ("X", Symbol.TypedefNameInfos.getValue().UnderlyingType);
-  }
+  SymbolInfo Symbol = SymbolInfo::CreateTypedefNameSymbolInfo(
+      "size_t_", HeaderName, {}, 2, {"unsigned int"});
+
+  Symbol = SymbolInfo::CreateTypedefNameSymbolInfo("X", HeaderName, {}, 3,
+                                                   {"struct X"});
+
+  Symbol =
+      SymbolInfo::CreateTypedefNameSymbolInfo("XX", HeaderName, {}, 4, {"X"});
 }
 
 } // namespace find_all_symbols
 } // namespace clang