[find-all-symbols] Slim SymbolInfo.

[hokein]

Summary

SymbolInfo has some optional fields, which is a bad-smell
implementation. For now, we

• remove the optional field since we don't need them (we can probably add them back if we actually need them in the future)
• make SymbolInfo to be a class.

By this change, the code is more simplified.

[hokein]

Update.

[bkramer]

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

95 ↗

(On Diff #56686)

Does folding Contexts into the tie not work?

[hokein]

Address comments.

[klimek]

lg

clang-tools-extra/trunk/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;
+      std::vector<SymbolInfo::Context> Contexts;
       for (auto IdentiferContext = Names.rbegin() + 1;
            IdentiferContext != Names.rend(); ++IdentiferContext) {
-        Info.Contexts.push_back(
-            {SymbolInfo::ContextType::Namespace, *IdentiferContext});
+        Contexts.emplace_back(SymbolInfo::ContextType::Namespace,
+                              *IdentiferContext);
       }
-      this->LookupTable[Info.Name].push_back(Info);
+
+      SymbolInfo Symbol(Names.back(), SymbolInfo::Class, Header, Contexts, 1);
+      this->LookupTable[Symbol.getName()].push_back(Symbol);
     }
   }
 }
 
 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

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

XrefsDBManager::search(llvm::StringRef Identifier) const {
   }
 
   DEBUG(llvm::dbgs() << "Searching " << Names.back() << "... got "
                      << Symbols.size() << " results...\n");
 
   std::vector<std::string> Results;
   for (const auto &Symbol : Symbols) {
     // Match the identifier name without qualifier.
-    if (Symbol.Name == Names.back()) {
+    if (Symbol.getName() == Names.back()) {
       bool IsMatched = true;
-      auto SymbolContext = Symbol.Contexts.begin();
+      auto SymbolContext = Symbol.getContexts().begin();
       // Match the remaining context names.
       for (auto IdentiferContext = Names.rbegin() + 1;
            IdentiferContext != Names.rend() &&
-           SymbolContext != Symbol.Contexts.end();
+           SymbolContext != Symbol.getContexts().end();
            ++IdentiferContext, ++SymbolContext) {
         if (SymbolContext->second != *IdentiferContext) {
           IsMatched = false;
           break;
         }
       }
 
       if (IsMatched) {
         // FIXME: file path should never be in the form of <...> or "...", but
         // the unit test with fixed database use <...> file path, which might
         // need to be changed.
         // FIXME: if the file path is a system header name, we want to use angle
         // brackets.
-        Results.push_back(
-            (Symbol.FilePath[0] == '"' || Symbol.FilePath[0] == '<')
-                ? Symbol.FilePath
-                : "\"" + Symbol.FilePath + "\"");
+        std::string FilePath = Symbol.getFilePath().str();
+        Results.push_back((FilePath[0] == '"' || FilePath[0] == '<')
+                              ? FilePath
+                              : "\"" + FilePath + "\"");
       }
     }
   }
   return Results;
 }
 
 } // namespace include_fixer
 } // namespace clang

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

if (auto DB = createFromFile(PathStorage))
       return DB;
   }
   return llvm::make_error_code(llvm::errc::no_such_file_or_directory);
 }
 
 std::vector<SymbolInfo> YamlXrefsDB::search(llvm::StringRef Identifier) {
   std::vector<SymbolInfo> Results;
   for (const auto &Symbol : Symbols) {
-    if (Symbol.Name == Identifier)
+    if (Symbol.getName() == Identifier)
       Results.push_back(Symbol);
   }
   return Results;
 }
 
 } // namespace include_fixer
 } // namespace clang

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

 #include "FindAllSymbols.h"
 #include "SymbolInfo.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/Type.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/ASTMatchers/ASTMatchers.h"
 #include "clang/Tooling/Tooling.h"
+#include "llvm/ADT/Optional.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace find_all_symbols {
 namespace {
-void SetContext(const NamedDecl *ND, SymbolInfo *Symbol) {
+std::vector<SymbolInfo::Context> GetContexts(const NamedDecl *ND) {
+  std::vector<SymbolInfo::Context> Contexts;
   for (const auto *Context = ND->getDeclContext(); Context;
        Context = Context->getParent()) {
     if (llvm::isa<TranslationUnitDecl>(Context) ||
         llvm::isa<LinkageSpecDecl>(Context))
       break;
 
     assert(llvm::isa<NamedDecl>(Context) &&
            "Expect Context to be a NamedDecl");
     if (const auto *NSD = dyn_cast<NamespaceDecl>(Context)) {
-      Symbol->Contexts.emplace_back(
-              SymbolInfo::Namespace,
-                  NSD->isAnonymousNamespace() ? "" : NSD->getName().str());
+      Contexts.emplace_back(SymbolInfo::Namespace, NSD->isAnonymousNamespace()
+                                                       ? ""
+                                                       : NSD->getName().str());
     } else {
       const auto *RD = cast<RecordDecl>(Context);
-      Symbol->Contexts.emplace_back(SymbolInfo::Record, RD->getName().str());
+      Contexts.emplace_back(SymbolInfo::Record, RD->getName().str());
     }
   }
+  return Contexts;
 }
 
-bool SetCommonInfo(const MatchFinder::MatchResult &Result,
-                   const NamedDecl *ND, SymbolInfo *Symbol) {
-  SetContext(ND, Symbol);
-
-  Symbol->Name = ND->getNameAsString();
+llvm::Optional<SymbolInfo> CreateSymbolInfo(const NamedDecl *ND,
+                                            const SourceManager &SM) {
+  SymbolInfo::SymbolKind Type;
+  if (llvm::isa<VarDecl>(ND)) {
+    Type = SymbolInfo::Variable;
+  } else if (llvm::isa<FunctionDecl>(ND)) {
+    Type = SymbolInfo::Function;
+  } else if (llvm::isa<TypedefNameDecl>(ND)) {
+    Type = SymbolInfo::TypedefName;
+  } else {
+    assert(llvm::isa<RecordDecl>(ND) && "Matched decl must be one of VarDecl, "
+                                        "FunctionDecl, TypedefNameDecl and "
+                                        "RecordDecl!");
+    // C-style record decl can have empty name, e.g "struct { ... } var;".
+    if (ND->getName().empty())
+      return llvm::None;
+    Type = SymbolInfo::Class;
+  }
 
-  const SourceManager *SM = Result.SourceManager;
-  SourceLocation Loc = SM->getExpansionLoc(ND->getLocation());
+  SourceLocation Loc = SM.getExpansionLoc(ND->getLocation());
   if (!Loc.isValid()) {
     llvm::errs() << "Declaration " << ND->getNameAsString() << "("
                  << ND->getDeclKindName()
                  << ") has invalid declaration location.";
-    return false;
+    return llvm::None;
   }
-
-  Symbol->LineNumber = SM->getExpansionLineNumber(Loc);
-
-  llvm::StringRef FilePath = SM->getFilename(Loc);
+  llvm::StringRef FilePath = SM.getFilename(Loc);
   if (FilePath.empty())
-    return false;
+    return llvm::None;
 
   llvm::SmallString<128> AbsolutePath;
   if (llvm::sys::path::is_absolute(FilePath)) {
     AbsolutePath = FilePath;
   } else {
-    auto WorkingDir = SM->getFileManager()
+    auto WorkingDir = SM.getFileManager()
                           .getVirtualFileSystem()
                           ->getCurrentWorkingDirectory();
     if (!WorkingDir)
-      return false;
+      return llvm::None;
     AbsolutePath = *WorkingDir;
     llvm::sys::path::append(AbsolutePath, FilePath);
   }
 
   llvm::sys::path::remove_dots(AbsolutePath, true);
-  Symbol->FilePath = AbsolutePath.str();
-  return true;
+  return SymbolInfo(ND->getNameAsString(), Type, AbsolutePath.str(),
+                    GetContexts(ND), SM.getExpansionLineNumber(Loc));
 }
+
 } // namespace
 
 void FindAllSymbols::registerMatchers(MatchFinder *MatchFinder) {
   // FIXME: Handle specialization.
   auto IsInSpecialization = hasAncestor(
       decl(anyOf(cxxRecordDecl(isExplicitTemplateSpecialization()),
                  functionDecl(isExplicitTemplateSpecialization()))));
 
void FindAllSymbols::run(const MatchFinder::MatchResult &Result) {
   if (Result.Context->getDiagnostics().hasErrorOccurred()) {
     return;
   }
 
   const NamedDecl *ND = Result.Nodes.getNodeAs<NamedDecl>("decl");
   assert(ND && "Matched declaration must be a NamedDecl!");
   const SourceManager *SM = Result.SourceManager;
 
-  SymbolInfo Symbol;
-  if (!SetCommonInfo(Result, ND, &Symbol))
-    return;
-
-  if (const auto *VD = llvm::dyn_cast<VarDecl>(ND)) {
-    Symbol.Type = SymbolInfo::Variable;
-    SymbolInfo::VariableInfo VI;
-    VI.Type = VD->getType().getAsString();
-    Symbol.VariableInfos = VI;
-  } else if (const auto *FD = llvm::dyn_cast<FunctionDecl>(ND)) {
-    Symbol.Type = SymbolInfo::Function;
-    SymbolInfo::FunctionInfo FI;
-    FI.ReturnType = FD->getReturnType().getAsString();
-    for (const auto *Param : FD->params())
-      FI.ParameterTypes.push_back(Param->getType().getAsString());
-    Symbol.FunctionInfos = FI;
-  } else if (const auto *TD = llvm::dyn_cast<TypedefNameDecl>(ND)) {
-    Symbol.Type = SymbolInfo::TypedefName;
-    SymbolInfo::TypedefNameInfo TI;
-    TI.UnderlyingType = TD->getUnderlyingType().getAsString();
-    Symbol.TypedefNameInfos = TI;
-  } else {
-    assert(
-        llvm::isa<RecordDecl>(ND) &&
-        "Matched decl must be one of VarDecl, FunctionDecl, and RecordDecl!");
-    // C-style record decl can have empty name, e.g "struct { ... } var;".
-    if (ND->getName().empty())
-      return;
-    Symbol.Type = SymbolInfo::Class;
-  }
-
-  const FileEntry *FE = SM->getFileEntryForID(SM->getMainFileID());
-  Reporter->reportResult(FE->getName(), Symbol);
+  llvm::Optional<SymbolInfo> Symbol = CreateSymbolInfo(ND, *SM);
+  if (Symbol)
+    Reporter->reportResult(
+        SM->getFileEntryForID(SM->getMainFileID())->getName(), *Symbol);
 }
 
 } // namespace find_all_symbols
 } // namespace clang

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

 //===-- SymbolInfo.h - find all symbols--------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_INCLUDE_FIXER_FIND_ALL_SYMBOLS_SYMBOL_INFO_H
 #define LLVM_CLANG_TOOLS_EXTRA_INCLUDE_FIXER_FIND_ALL_SYMBOLS_SYMBOL_INFO_H
 
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringRef.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.
-// FIXME: add static members for creating complete instances.
-struct SymbolInfo {
+class SymbolInfo {
+public:
+  /// \brief The SymbolInfo Type.
   enum SymbolKind {
     Function,
     Class,
     Variable,
     TypedefName,
+    Unknown,
   };
 
+  /// \brief The Context Type.
   enum ContextType {
     Namespace, // Symbols declared in a namespace.
     Record,    // Symbols declared in a class.
   };
 
+  /// \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(Unknown), LineNumber(-1) {};
+
+  SymbolInfo(llvm::StringRef Name, SymbolKind Type, llvm::StringRef FilePath,
+             const std::vector<Context> &Contexts, int LineNumber);
+
+  /// \brief Get symbol name.
+  llvm::StringRef getName() const;
+
+  /// \brief Get symbol type.
+  SymbolKind getSymbolKind() const;
+
+  /// \brief Get the file path where symbol comes from
+  llvm::StringRef getFilePath() const;
+
+  /// \brief Get symbol contexts.
+  const std::vector<SymbolInfo::Context> &getContexts() const;
+
+  /// \brief Get a 1-based line number of the symbol's declaration.
+  int getLineNumber() const;
+
+  bool operator<(const SymbolInfo &Symbol) const;
+
+  bool operator==(const SymbolInfo &Symbol) const;
+
+private:
+  friend struct llvm::yaml::MappingTraits<SymbolInfo>;
+
   /// \brief Identifier name.
   std::string Name;
 
   /// \brief Symbol type.
   SymbolKind Type;
 
   /// \brief The file path where the symbol comes from.
   std::string FilePath;
 
-  /// \brief A pair of <ContextType, ContextName>.
-  typedef std::pair<ContextType, std::string> Context;
-
   /// \brief Contains information about symbol contexts. Context information is
   /// stored from the inner-most level to outer-most level.
   ///
   /// 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 FunctionInfo {
-    std::string ReturnType;
-    std::vector<std::string> ParameterTypes;
-  };
-
-  struct TypedefNameInfo {
-    std::string UnderlyingType;
-  };
-
-  struct VariableInfo {
-    std::string 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;
 };
 
 /// \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

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

 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.mapOptional("Variable", Symbol.VariableInfos);
-    io.mapOptional("Function", Symbol.FunctionInfos);
-    io.mapOptional("TypedefName", Symbol.TypedefNameInfos);
   }
 };
 
 template <> struct ScalarEnumerationTraits<ContextType> {
   static void enumeration(IO &io, ContextType &value) {
     io.enumCase(value, "Record", ContextType::Record);
     io.enumCase(value, "Namespace", ContextType::Namespace);
   }

 
 template <> struct MappingTraits<SymbolInfo::Context> {
   static void mapping(IO &io, SymbolInfo::Context &Context) {
     io.mapRequired("ContextType", Context.first);
     io.mapRequired("ContextName", Context.second);
   }
 };
 
-template <> struct MappingTraits<SymbolInfo::FunctionInfo> {
-  static void mapping(IO &io, SymbolInfo::FunctionInfo &Value) {
-    io.mapRequired("ReturnType", Value.ReturnType);
-    io.mapRequired("ParameterTypes", Value.ParameterTypes);
-  }
-};
-
-template <> struct MappingTraits<SymbolInfo::VariableInfo> {
-  static void mapping(IO &io, SymbolInfo::VariableInfo &Value) {
-    io.mapRequired("VariableType", Value.Type);
-  }
-};
-
-template <> struct MappingTraits<SymbolInfo::TypedefNameInfo> {
-  static void mapping(IO &io, SymbolInfo::TypedefNameInfo &Value) {
-    io.mapRequired("TypedefNameType", Value.UnderlyingType);
-  }
-};
-
 } // 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)
+    : 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; }
+
+const std::vector<SymbolInfo::Context> &SymbolInfo::getContexts() const {
+  return Contexts;
+}
+
+int SymbolInfo::getLineNumber() const { return LineNumber; }
+
 bool SymbolInfo::operator==(const SymbolInfo &Symbol) const {
-  return Name == Symbol.Name && FilePath == Symbol.FilePath &&
-         LineNumber == Symbol.LineNumber && Contexts == Symbol.Contexts;
+  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, FilePath, LineNumber) <
-         std::tie(Symbol.Name, Symbol.FilePath, Symbol.LineNumber);
+  return std::tie(Name, Type, FilePath, LineNumber, Contexts) <
+         std::tie(Symbol.Name, Symbol.Type, Symbol.FilePath, Symbol.LineNumber,
+                  Symbol.Contexts);
 }
 
 bool WriteSymbolInfosToStream(llvm::raw_ostream &OS,
                               const std::set<SymbolInfo> &Symbols) {
   llvm::yaml::Output yout(OS);
   for (auto Symbol : Symbols)
     yout << Symbol;
   return true;

clang-tools-extra/trunk/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,
+SymbolInfo CreateSymbolInfo(StringRef Name, SymbolInfo::SymbolKind Type,
+                            StringRef 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;
+  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::Variable, HeaderName, 2, {});
-    EXPECT_TRUE(hasSymbol(Symbol));
-    getSymbolExtraInfo(Symbol);
-    EXPECT_EQ("int", Symbol.VariableInfos.getValue().Type);
-  }
-  {
-    SymbolInfo Symbol =
-        CreateSymbolInfo("SSSS", SymbolInfo::Variable, HeaderName, 4,
+
+  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);
-  }
+
+  Symbol = CreateSymbolInfo(
 }
 
 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));
-  }
-}
+
+  Symbol = CreateSymbolInfo("C_struct", SymbolInfo::Class, 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));
-  }
-}
+
+  Symbol = CreateSymbolInfo("A", SymbolInfo::Class, HeaderName, 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));
-  }
-}
 
 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 Symbol = CreateSymbolInfo("gg", SymbolInfo::Function, HeaderName,
+                                       3, {{SymbolInfo::Namespace, "na"}});
+
+  Symbol = CreateSymbolInfo("f", SymbolInfo::Function, HeaderName, 4,
+
+  Symbol = CreateSymbolInfo("SSSFFF", SymbolInfo::Function, 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]);
-  }
+
+  Symbol = CreateSymbolInfo(
+      "fun", SymbolInfo::Function, HeaderName, 10,
 }
 
 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);
-  }
+
+  Symbol = CreateSymbolInfo("X2", SymbolInfo::Variable, HeaderName, 3,
+                            {{SymbolInfo::Namespace, ""}});
+
+  Symbol = CreateSymbolInfo(
+
+  Symbol = CreateSymbolInfo(
 }
 
 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, {});
+      CreateSymbolInfo("DecayedFunc", SymbolInfo::Function, HeaderName, 1, {});
   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);
-  }
+
+  Symbol = CreateSymbolInfo("X", SymbolInfo::TypedefName, HeaderName, 3, {});
+
+  Symbol = CreateSymbolInfo("XX", SymbolInfo::TypedefName, HeaderName, 4, {});
 }
 
 } // namespace find_all_symbols
 } // namespace clang