SymbolVendor: Remove the type list member

[labath]

Summary

Similarly to the compile unit lists, the list of types can also be
managed by the symbol file itself.

Since the only purpose of this list seems to be to maintain an owning
reference to all the types a symbol file has created (items are only
ever added to the list, never retrieved), I remove the passthrough
functions in SymbolVendor and Module. I also tighten the interface of
the function (return a reference instead of a pointer, make it protected
instead of public).

[JDevlieghere]

source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp

1286 ↗

(On Diff #211268)

nit: maybe we can const this and the one below?

lldb/trunk/include/lldb/Core/Module.h

public:
   ///     plug-in can be found that can use the object file, nullptr will
   ///     be returned, else a valid symbol vendor plug-in interface
   ///     will be returned. The returned pointer is owned by this
   ///     object and remains valid as long as the object is around.
   virtual SymbolVendor *
   GetSymbolVendor(bool can_create = true,
                   lldb_private::Stream *feedback_strm = nullptr);
 
-  /// Get accessor the type list for this module.
-  ///
-  /// \return
-  ///     A valid type list pointer, or nullptr if there is no valid
-  ///     symbol vendor for this module.
-  TypeList *GetTypeList();
-
   /// Get a reference to the UUID value contained in this object.
   ///
   /// If the executable image file doesn't not have a UUID value built into
   /// the file format, an MD5 checksum of the entire file, or slice of the
   /// file for the current architecture should be used.
   ///
   /// \return
   ///     A const pointer to the internal copy of the UUID value in

lldb/trunk/include/lldb/Symbol/SymbolFile.h

 
 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Symbol/CompilerDecl.h"
 #include "lldb/Symbol/CompilerDeclContext.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/SourceModule.h"
 #include "lldb/Symbol/Type.h"
+#include "lldb/Symbol/TypeList.h"
 #include "lldb/lldb-private.h"
 
 #include "llvm/ADT/DenseSet.h"
 
 #include <mutex>
 
 #if defined(LLDB_CONFIGURATION_DEBUG)
 #define ASSERT_MODULE_LOCK(expr) (expr->AssertModuleLock())
FindTypes(ConstString name, const CompilerDeclContext *parent_decl_ctx,
             llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
             TypeMap &types);
   virtual size_t FindTypes(const std::vector<CompilerContext> &context,
                            bool append, TypeMap &types);
 
   virtual void
   GetMangledNamesForFunction(const std::string &scope_qualified_name,
                              std::vector<ConstString> &mangled_names);
-  //  virtual uint32_t        FindTypes (const SymbolContext& sc, const
-  //  RegularExpression& regex, bool append, uint32_t max_matches, TypeList&
-  //  types) = 0;
-  virtual TypeList *GetTypeList();
+
   virtual size_t GetTypes(lldb_private::SymbolContextScope *sc_scope,
                           lldb::TypeClass type_mask,
                           lldb_private::TypeList &type_list) = 0;
 
   virtual void PreloadSymbols();
 
   virtual lldb_private::TypeSystem *
   GetTypeSystemForLanguage(lldb::LanguageType language);
public:
   }
 
   virtual void Dump(Stream &s);
 
 protected:
   void AssertModuleLock();
   virtual uint32_t CalculateNumCompileUnits() = 0;
   virtual lldb::CompUnitSP ParseCompileUnitAtIndex(uint32_t idx) = 0;
+  virtual TypeList &GetTypeList() { return m_type_list; }
 
   void SetCompileUnitAtIndex(uint32_t idx, const lldb::CompUnitSP &cu_sp);
 
   ObjectFile *m_obj_file; // The object file that symbols can be extracted from.
   llvm::Optional<std::vector<lldb::CompUnitSP>> m_compile_units;
+  TypeList m_type_list;
   uint32_t m_abilities;
   bool m_calculated_abilities;
 
 private:
   DISALLOW_COPY_AND_ASSIGN(SymbolFile);
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_SymbolFile_h_

lldb/trunk/include/lldb/Symbol/SymbolVendor.h

 //===-- SymbolVendor.h ------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_SymbolVendor_h_
 #define liblldb_SymbolVendor_h_
 
 #include <vector>
 
 #include "lldb/Core/ModuleChild.h"
 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Symbol/SourceModule.h"
-#include "lldb/Symbol/TypeList.h"
 #include "lldb/Symbol/TypeMap.h"
 #include "lldb/lldb-private.h"
 #include "llvm/ADT/DenseSet.h"
 
 namespace lldb_private {
 
 // The symbol vendor class is designed to abstract the process of searching for
 // debug information for a given module. Platforms can subclass this class and
public:
   virtual CompilerDeclContext
   FindNamespace(ConstString name,
                 const CompilerDeclContext *parent_decl_ctx);
 
   virtual size_t GetNumCompileUnits();
 
   virtual lldb::CompUnitSP GetCompileUnitAtIndex(size_t idx);
 
-  TypeList &GetTypeList() { return m_type_list; }
-
-  const TypeList &GetTypeList() const { return m_type_list; }
-
   virtual size_t GetTypes(SymbolContextScope *sc_scope,
                           lldb::TypeClass type_mask, TypeList &type_list);
 
   SymbolFile *GetSymbolFile() { return m_sym_file_up.get(); }
 
   FileSpec GetMainFileSpec() const;
 
   // Get module unified section list symbol table.
   virtual Symtab *GetSymtab();
 
   // Clear module unified section list symbol table.
   virtual void ClearSymtab();
 
   /// Notify the SymbolVendor that the file addresses in the Sections
   /// for this module have been changed.
   virtual void SectionFileAddressesChanged();
 
   // PluginInterface protocol
   ConstString GetPluginName() override;
 
   uint32_t GetPluginVersion() override;
 
 protected:
-  TypeList m_type_list; // Uniqued types for all parsers owned by this module
   lldb::ObjectFileSP m_objfile_sp; // Keep a reference to the object file in
                                    // case it isn't the same as the module
                                    // object file (debug symbols in a separate
                                    // file)
   std::unique_ptr<SymbolFile> m_sym_file_up; // A single symbol file. Subclasses
                                              // can add more of these if needed.
   Symtab *m_symtab; // Save a symtab once to not pass it through `AddSymbols` of
                     // the symbol file each time when it is needed

lldb/trunk/include/lldb/Symbol/Type.h

public:
   // Type instances. They can store a weak pointer to the Module;
   lldb::ModuleSP GetModule();
 
   void GetDescription(Stream *s, lldb::DescriptionLevel level, bool show_name);
 
   SymbolFile *GetSymbolFile() { return m_symbol_file; }
   const SymbolFile *GetSymbolFile() const { return m_symbol_file; }
 
-  TypeList *GetTypeList();
-
   ConstString GetName();
 
   llvm::Optional<uint64_t> GetByteSize();
 
   uint32_t GetNumChildren(bool omit_empty_base_classes);
 
   bool IsAggregateType();
 

lldb/trunk/source/API/SBCompileUnit.cpp

 #include "lldb/API/SBLineEntry.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/LineEntry.h"
 #include "lldb/Symbol/LineTable.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Symbol/Type.h"
+#include "lldb/Symbol/TypeList.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 SBCompileUnit::SBCompileUnit() : m_opaque_ptr(nullptr) {
   LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCompileUnit);
 }
 

lldb/trunk/source/Core/Module.cpp

void Module::Dump(Stream *s) {
 
   SymbolVendor *symbols = GetSymbolVendor();
   if (symbols)
     symbols->Dump(s);
 
   s->IndentLess();
 }
 
-TypeList *Module::GetTypeList() {
-  SymbolVendor *symbols = GetSymbolVendor();
-  if (symbols)
-    return &symbols->GetTypeList();
-  return nullptr;
-}
-
 ConstString Module::GetObjectName() const { return m_object_name; }
 
 ObjectFile *Module::GetObjectFile() {
   if (!m_did_load_objfile.load()) {
     std::lock_guard<std::recursive_mutex> guard(m_mutex);
     if (!m_did_load_objfile.load()) {
       static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
       Timer scoped_timer(func_cat, "Module::GetObjectFile () module = %s",

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

if (!type)
     return TypeSP();
 
   SymbolFileDWARF *dwarf = die.GetDWARF();
   TypeSP type_sp(new Type(
       die.GetID(), dwarf, dwo_type_sp->GetName(), dwo_type_sp->GetByteSize(),
       nullptr, LLDB_INVALID_UID, Type::eEncodingInvalid,
       &dwo_type_sp->GetDeclaration(), type, Type::eResolveStateForward));
 
-  dwarf->GetTypeList()->Insert(type_sp);
+  dwarf->GetTypeList().Insert(type_sp);
   dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
   clang::TagDecl *tag_decl = ClangASTContext::GetAsTagDecl(type);
   if (tag_decl)
     LinkDeclContextToDIE(tag_decl, die);
   else {
     clang::DeclContext *defn_decl_ctx = GetCachedClangDeclContextForDIE(die);
     if (defn_decl_ctx)
       LinkDeclContextToDIE(defn_decl_ctx, die);
if (TypeSP type_sp =
       if (clang::DeclContext *decl_ctx =
               GetCachedClangDeclContextForDIE(signature_die))
         LinkDeclContextToDIE(decl_ctx, die);
       return type_sp;
     }
     return nullptr;
   }
 
-  TypeList *type_list = dwarf->GetTypeList();
+  TypeList &type_list = dwarf->GetTypeList();
   if (type_is_new_ptr)
     *type_is_new_ptr = true;
 
   const dw_tag_t tag = die.Tag();
 
   Type::ResolveState resolve_state = Type::eResolveStateUnresolved;
 
   Type::EncodingDataType encoding_data_type = Type::eEncodingIsUID;
if (sc_parent_tag == DW_TAG_compile_unit ||
       symbol_context_scope = sc.module_sp.get();
 
     if (symbol_context_scope != NULL) {
       type_sp->SetSymbolContextScope(symbol_context_scope);
     }
 
     // We are ready to put this type into the uniqued list up at the module
     // level
-    type_list->Insert(type_sp);
+    type_list.Insert(type_sp);
 
     dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
   }
   return type_sp;
 }
 
 // DWARF parsing functions
 

lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

FindTypes(lldb_private::ConstString name,
             const lldb_private::CompilerDeclContext *parent_decl_ctx,
             bool append, uint32_t max_matches,
             llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
             lldb_private::TypeMap &types) override;
 
   size_t FindTypes(const std::vector<lldb_private::CompilerContext> &context,
                    bool append, lldb_private::TypeMap &types) override;
 
-  lldb_private::TypeList *GetTypeList() override;
-
   size_t GetTypes(lldb_private::SymbolContextScope *sc_scope,
                   lldb::TypeClass type_mask,
                   lldb_private::TypeList &type_list) override;
 
   lldb_private::TypeSystem *
   GetTypeSystemForLanguage(lldb::LanguageType language) override;
 
   lldb_private::CompilerDeclContext FindNamespace(
protected:
 
   bool DeclContextMatchesThisSymbolFile(
       const lldb_private::CompilerDeclContext *decl_ctx);
 
   uint32_t CalculateNumCompileUnits() override;
 
   lldb::CompUnitSP ParseCompileUnitAtIndex(uint32_t index) override;
 
+  lldb_private::TypeList &GetTypeList() override;
+
   virtual DWARFUnit *
   GetDWARFCompileUnit(lldb_private::CompileUnit *comp_unit);
 
   DWARFUnit *GetNextUnparsedDWARFCompileUnit(DWARFUnit *prev_cu);
 
   bool GetFunction(const DWARFDIE &die, lldb_private::SymbolContext &sc);
 
   lldb_private::Function *ParseFunction(lldb_private::CompileUnit &comp_unit,

lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

const char *SymbolFileDWARF::GetPluginDescriptionStatic() {
   return "DWARF and DWARF3 debug symbol file reader.";
 }
 
 SymbolFile *SymbolFileDWARF::CreateInstance(ObjectFile *obj_file) {
   return new SymbolFileDWARF(obj_file,
                              /*dwo_section_list*/ nullptr);
 }
 
-TypeList *SymbolFileDWARF::GetTypeList() {
+TypeList &SymbolFileDWARF::GetTypeList() {
   // This method can be called without going through the symbol vendor so we
   // need to lock the module.
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
-  SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile();
-  if (debug_map_symfile)
+  if (SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile())
     return debug_map_symfile->GetTypeList();
-  else
-    return m_obj_file->GetModule()->GetTypeList();
+  return SymbolFile::GetTypeList();
 }
 void SymbolFileDWARF::GetTypes(const DWARFDIE &die, dw_offset_t min_die_offset,
                                dw_offset_t max_die_offset, uint32_t type_mask,
                                TypeSet &type_set) {
   if (die) {
     const dw_offset_t die_offset = die.GetOffset();
 
     if (die_offset >= max_die_offset)
TypeSP SymbolFileDWARF::ParseType(const SymbolContext &sc, const DWARFDIE &die,
 
   DWARFASTParser *dwarf_ast = type_system->GetDWARFParser();
   if (!dwarf_ast)
     return {};
 
   Log *log = LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO);
   TypeSP type_sp = dwarf_ast->ParseTypeFromDWARF(sc, die, log, type_is_new_ptr);
   if (type_sp) {
-    TypeList *type_list = GetTypeList();
-    if (type_list)
-      type_list->Insert(type_sp);
+    GetTypeList().Insert(type_sp);
 
     if (die.Tag() == DW_TAG_subprogram) {
       std::string scope_qualified_name(GetDeclContextForUID(die.GetID())
                                            .GetScopeQualifiedName()
                                            .AsCString(""));
       if (scope_qualified_name.size()) {
         m_function_scope_qualified_name_map[scope_qualified_name].insert(
             die.GetID());

lldb/trunk/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp

TypeSP SymbolFileNativePDB::GetOrCreateType(PdbTypeSymId type_id) {
   // a type could create nested types, which could invalidate iterators.  So
   // we have to do a 2-phase lookup / insert.
   auto iter = m_types.find(toOpaqueUid(type_id));
   if (iter != m_types.end())
     return iter->second;
 
   TypeSP type = CreateAndCacheType(type_id);
   if (type)
-    m_obj_file->GetModule()->GetTypeList()->Insert(type);
+    GetTypeList().Insert(type);
   return type;
 }
 
 VariableSP SymbolFileNativePDB::CreateGlobalVariable(PdbGlobalSymId var_id) {
   CVSymbol sym = m_index->symrecords().readRecord(var_id.offset);
   if (sym.kind() == S_CONSTANT)
     return CreateConstantSymbol(var_id, sym);
 
size_t SymbolFileNativePDB::FindTypesByName(llvm::StringRef name,
   return match_count;
 }
 
 size_t SymbolFileNativePDB::ParseTypes(CompileUnit &comp_unit) {
   // Only do the full type scan the first time.
   if (m_done_full_type_scan)
     return 0;
 
-  size_t old_count = m_obj_file->GetModule()->GetTypeList()->GetSize();
+  const size_t old_count = GetTypeList().GetSize();
   LazyRandomTypeCollection &types = m_index->tpi().typeCollection();
 
   // First process the entire TPI stream.
   for (auto ti = types.getFirst(); ti; ti = types.getNext(*ti)) {
     TypeSP type = GetOrCreateType(*ti);
     if (type)
       (void)type->GetFullCompilerType();
   }
if (IsTagRecord(PdbTypeSymId{udt.Type, false}, m_index->tpi())) {
       if (name == udt.Name)
         is_typedef = false;
     }
 
     if (is_typedef)
       GetOrCreateTypedef(global);
   }
 
-  size_t new_count = m_obj_file->GetModule()->GetTypeList()->GetSize();
+  const size_t new_count = GetTypeList().GetSize();
 
   m_done_full_type_scan = true;
 
   return new_count - old_count;
 }
 
 size_t
 SymbolFileNativePDB::ParseVariablesForCompileUnit(CompileUnit &comp_unit,

lldb/trunk/source/Plugins/SymbolFile/PDB/SymbolFilePDB.h

FindTypes(lldb_private::ConstString name,
             lldb_private::TypeMap &types) override;
 
   size_t FindTypes(const std::vector<lldb_private::CompilerContext> &context,
                    bool append, lldb_private::TypeMap &types) override;
 
   void FindTypesByRegex(const lldb_private::RegularExpression &regex,
                         uint32_t max_matches, lldb_private::TypeMap &types);
 
-  lldb_private::TypeList *GetTypeList() override;
-
   size_t GetTypes(lldb_private::SymbolContextScope *sc_scope,
                   lldb::TypeClass type_mask,
                   lldb_private::TypeList &type_list) override;
 
   lldb_private::TypeSystem *
   GetTypeSystemForLanguage(lldb::LanguageType language) override;
 
   lldb_private::CompilerDeclContext FindNamespace(

lldb/trunk/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp

lldb_private::Type *SymbolFilePDB::ResolveTypeUID(lldb::user_id_t type_uid) {
 
   auto pdb_type = m_session_up->getSymbolById(type_uid);
   if (pdb_type == nullptr)
     return nullptr;
 
   lldb::TypeSP result = pdb->CreateLLDBTypeFromPDBType(*pdb_type);
   if (result) {
     m_types.insert(std::make_pair(type_uid, result));
-    auto type_list = GetTypeList();
-    if (type_list)
-      type_list->Insert(result);
+    GetTypeList().Insert(result);
   }
   return result.get();
 }
 
 llvm::Optional<SymbolFile::ArrayInfo> SymbolFilePDB::GetDynamicArrayInfoForUID(
     lldb::user_id_t type_uid, const lldb_private::ExecutionContext *exe_ctx) {
   return llvm::None;
 }

 }
 
 size_t SymbolFilePDB::FindTypes(
     const std::vector<lldb_private::CompilerContext> &contexts, bool append,
     lldb_private::TypeMap &types) {
   return 0;
 }
 
-lldb_private::TypeList *SymbolFilePDB::GetTypeList() {
-  return m_obj_file->GetModule()->GetTypeList();
-}
-
 void SymbolFilePDB::GetTypesForPDBSymbol(const llvm::pdb::PDBSymbol &pdb_symbol,
                                          uint32_t type_mask,
                                          TypeCollection &type_collection) {
   bool can_parse = false;
   switch (pdb_symbol.getSymTag()) {
   case PDB_SymType::ArrayType:
     can_parse = ((type_mask & eTypeClassArray) != 0);
     break;

lldb/trunk/source/Symbol/SymbolFile.cpp

if (best_symfile_up) {
       // Let the winning symbol file parser initialize itself more completely
       // now that it has been chosen
       best_symfile_up->InitializeObject();
     }
   }
   return best_symfile_up.release();
 }
 
-TypeList *SymbolFile::GetTypeList() {
-  if (m_obj_file)
-    return m_obj_file->GetModule()->GetTypeList();
-  return nullptr;
-}
-
 TypeSystem *SymbolFile::GetTypeSystemForLanguage(lldb::LanguageType language) {
   TypeSystem *type_system =
       m_obj_file->GetModule()->GetTypeSystemForLanguage(language);
   if (type_system)
     type_system->SetSymbolFile(this);
   return type_system;
 }
 
void SymbolFile::SetCompileUnitAtIndex(uint32_t idx, const CompUnitSP &cu_sp) {
   // once, so if this assertion fails, we need to make sure that we don't
   // have a race condition, or have a second parse of the same compile
   // unit.
   assert((*m_compile_units)[idx] == nullptr);
   (*m_compile_units)[idx] = cu_sp;
 }
 
 void SymbolFile::Dump(Stream &s) {
+  s.PutCString("Types:\n");
+  m_type_list.Dump(&s, /*show_context*/ false);
+  s.PutChar('\n');
+
   s.PutCString("Compile units:\n");
   if (m_compile_units) {
     for (const CompUnitSP &cu_sp : *m_compile_units) {
       // We currently only dump the compile units that have been parsed
       if (cu_sp)
         cu_sp->Dump(&s, /*show_context*/ false);
     }
   }
   s.PutChar('\n');
 }
 
 SymbolFile::RegisterInfoResolver::~RegisterInfoResolver() = default;

lldb/trunk/source/Symbol/SymbolVendor.cpp

if (!sym_objfile_sp)
     sym_objfile_sp = module_sp->GetObjectFile()->shared_from_this();
   instance_up.reset(new SymbolVendor(module_sp));
   instance_up->AddSymbolFileRepresentation(sym_objfile_sp);
   return instance_up.release();
 }
 
 // SymbolVendor constructor
 SymbolVendor::SymbolVendor(const lldb::ModuleSP &module_sp)
-    : ModuleChild(module_sp), m_type_list(), m_sym_file_up(), m_symtab() {}
+    : ModuleChild(module_sp), m_sym_file_up(), m_symtab() {}
 
 // Destructor
 SymbolVendor::~SymbolVendor() {}
 
 // Add a representation given an object file.
 void SymbolVendor::AddSymbolFileRepresentation(const ObjectFileSP &objfile_sp) {
   ModuleSP module_sp(GetModule());
   if (module_sp) {
SymbolVendor::FindNamespace(ConstString name,
   return namespace_decl_ctx;
 }
 
 void SymbolVendor::Dump(Stream *s) {
   ModuleSP module_sp(GetModule());
   if (module_sp) {
     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
 
-    bool show_context = false;
-
     s->Printf("%p: ", static_cast<void *>(this));
     s->Indent();
     s->PutCString("SymbolVendor");
     if (m_sym_file_up) {
       *s << " " << m_sym_file_up->GetPluginName();
       ObjectFile *objfile = m_sym_file_up->GetObjectFile();
       if (objfile) {
         const FileSpec &objfile_file_spec = objfile->GetFileSpec();
         if (objfile_file_spec) {
           s->PutCString(" (");
           objfile_file_spec.Dump(s);
           s->PutChar(')');
         }
       }
     }
     s->EOL();
-    s->PutCString("Types:\n");
-    m_type_list.Dump(s, show_context);
-    s->EOL();
     if (m_sym_file_up)
       m_sym_file_up->Dump(*s);
     s->IndentMore();
 
     if (Symtab *symtab = GetSymtab())
       symtab->Dump(s, nullptr, eSortOrderNone);
 
     s->IndentLess();

lldb/trunk/source/Symbol/Type.cpp

bool Type::ReadFromMemory(ExecutionContext *exe_ctx, lldb::addr_t addr,
   return false;
 }
 
 bool Type::WriteToMemory(ExecutionContext *exe_ctx, lldb::addr_t addr,
                          AddressType address_type, DataExtractor &data) {
   return false;
 }
 
-TypeList *Type::GetTypeList() { return GetSymbolFile()->GetTypeList(); }
-
 const Declaration &Type::GetDeclaration() const { return m_decl; }
 
 bool Type::ResolveClangType(ResolveState compiler_type_resolve_state) {
   // TODO: This needs to consider the correct type system to use.
   Type *encoding_type = nullptr;
   if (!m_compiler_type.IsValid()) {
     encoding_type = GetEncodingType();
     if (encoding_type) {