[SymbolFilePDB] Remove a few null pointer checks by passing ref

[zturner]

Feel free to use your own judgement, and if you think it doesn't pass some complexity threshold, you can just submit without review and we can do post-commit review.

source/Plugins/SymbolFile/PDB/PDBASTParser.cpp

lldb::Encoding TranslateEnumEncoding(PDB_VariantType type) {
   default:
     break;
   }
 
   return lldb::eEncodingSint;
 }
 
 CompilerType GetBuiltinTypeForPDBEncodingAndBitSize(
-    ClangASTContext *clang_ast, const PDBSymbolTypeBuiltin *pdb_type,
+    ClangASTContext &clang_ast, const PDBSymbolTypeBuiltin &pdb_type,
     Encoding encoding, uint32_t width) {
-  if (!pdb_type)
-    return CompilerType();
-  if (!clang_ast)
-    return CompilerType();
-  auto *ast = clang_ast->getASTContext();
+  auto *ast = clang_ast.getASTContext();
   if (!ast)
     return CompilerType();
 
-  switch (pdb_type->getBuiltinType()) {
+  switch (pdb_type.getBuiltinType()) {
   default: break;
   case PDB_BuiltinType::None:
     return CompilerType();
   case PDB_BuiltinType::Void:
-    return clang_ast->GetBasicType(eBasicTypeVoid);
+    return clang_ast.GetBasicType(eBasicTypeVoid);
   case PDB_BuiltinType::Bool:
-    return clang_ast->GetBasicType(eBasicTypeBool);
+    return clang_ast.GetBasicType(eBasicTypeBool);
   case PDB_BuiltinType::Long:
     if (width == ast->getTypeSize(ast->LongTy))
       return CompilerType(ast, ast->LongTy);
     if (width == ast->getTypeSize(ast->LongLongTy))
       return CompilerType(ast, ast->LongLongTy);
     break;
   case PDB_BuiltinType::ULong:
     if (width == ast->getTypeSize(ast->UnsignedLongTy))
case PDB_BuiltinType::Float:
     // Note: types `long double` and `double` have same bit size in MSVC and there
     // is no information in the PDB to distinguish them. So when falling back
     // to default search, the compiler type of `long double` will be represented by
     // the one generated for `double`.
     break;
   }
   // If there is no match on PDB_BuiltinType, fall back to default search
   // by encoding and width only
-  return clang_ast->GetBuiltinTypeForEncodingAndBitSize(encoding, width);
+  return clang_ast.GetBuiltinTypeForEncodingAndBitSize(encoding, width);
 }
 
-ConstString GetPDBBuiltinTypeName(const PDBSymbolTypeBuiltin *pdb_type,
+ConstString GetPDBBuiltinTypeName(const PDBSymbolTypeBuiltin &pdb_type,
                                   CompilerType &compiler_type) {
-  if (!pdb_type)
-    return compiler_type.GetTypeName();
-
-  PDB_BuiltinType kind = pdb_type->getBuiltinType();
+  PDB_BuiltinType kind = pdb_type.getBuiltinType();
   switch (kind) {
   default: break;
   case PDB_BuiltinType::Currency:
     return ConstString("CURRENCY");
   case PDB_BuiltinType::Date:
     return ConstString("DATE");
   case PDB_BuiltinType::Variant:
     return ConstString("VARIANT");
case PDB_SymType::Enum: {
     if (first_child) {
       encoding = TranslateEnumEncoding(first_child->getValue().Type);
     }
     std::string name = enum_type->getName();
     uint64_t bytes = enum_type->getLength();
     CompilerType builtin_type;
     if (bytes > 0)
       builtin_type = GetBuiltinTypeForPDBEncodingAndBitSize(
-           &m_ast, underlying_type_up.get(), encoding, bytes * 8);
+           m_ast, *underlying_type_up, encoding, bytes * 8);
     else
       builtin_type = m_ast.GetBasicType(eBasicTypeInt);
     // FIXME: PDB does not have information about scoped enumeration (Enum Class).
     // Set it false for now.
     bool isScoped = false;
 
     CompilerType ast_enum = m_ast.CreateEnumerationType(
         name.c_str(), tu_decl_ctx, decl, builtin_type, isScoped);
case PDB_SymType::BuiltinType: {
     assert(builtin_type);
     PDB_BuiltinType builtin_kind = builtin_type->getBuiltinType();
     if (builtin_kind == PDB_BuiltinType::None)
       return nullptr;
 
     uint64_t bytes = builtin_type->getLength();
     Encoding encoding = TranslateBuiltinEncoding(builtin_kind);
     CompilerType builtin_ast_type = GetBuiltinTypeForPDBEncodingAndBitSize(
-        &m_ast, builtin_type, encoding, bytes * 8);
+        m_ast, *builtin_type, encoding, bytes * 8);
 
     if (builtin_type->isConstType())
       builtin_ast_type = builtin_ast_type.AddConstModifier();
 
     if (builtin_type->isVolatileType())
       builtin_ast_type = builtin_ast_type.AddVolatileModifier();
 
-    auto type_name = GetPDBBuiltinTypeName(builtin_type, builtin_ast_type);
+    auto type_name = GetPDBBuiltinTypeName(*builtin_type, builtin_ast_type);
 
     return std::make_shared<lldb_private::Type>(
         builtin_type->getSymIndexId(), m_ast.GetSymbolFile(), type_name,
         bytes, nullptr, LLDB_INVALID_UID, lldb_private::Type::eEncodingIsUID,
         decl, builtin_ast_type, lldb_private::Type::eResolveStateFull);
   } break;
   case PDB_SymType::PointerType: {
     auto *pointer_type = llvm::dyn_cast<PDBSymbolTypePointer>(&type);

source/Plugins/SymbolFile/PDB/SymbolFilePDB.h

void FindTypesByName(const std::string &name, uint32_t max_matches,
                        lldb_private::TypeMap &types);
 
   lldb::CompUnitSP
   GetCompileUnitContainsAddress(const lldb_private::Address &so_addr);
 
   typedef std::vector<lldb_private::Type*> TypeCollection;
 
   void
-  GetTypesForPDBSymbol(const llvm::pdb::PDBSymbol *pdb_symbol,
+  GetTypesForPDBSymbol(const llvm::pdb::PDBSymbol &pdb_symbol,
                        uint32_t type_mask, TypeCollection &type_collection);
 
   lldb_private::Function* ParseCompileUnitFunctionForPDBFunc(
-      const llvm::pdb::PDBSymbolFunc *pdb_func,
+      const llvm::pdb::PDBSymbolFunc &pdb_func,
       const lldb_private::SymbolContext &sc);
 
-  void GetCompileUnitIndex(const llvm::pdb::PDBSymbolCompiland *pdb_compiland,
+  void GetCompileUnitIndex(const llvm::pdb::PDBSymbolCompiland &pdb_compiland,
                            uint32_t &index);
 
   std::string GetSourceFileNameForPDBCompiland(
       const llvm::pdb::PDBSymbolCompiland *pdb_compiland);
 
   std::unique_ptr<llvm::pdb::PDBSymbolCompiland>
   GetPDBCompilandByUID(uint32_t uid);
 
   lldb_private::Mangled
-  GetMangledForPDBFunc(const llvm::pdb::PDBSymbolFunc *pdb_func);
+  GetMangledForPDBFunc(const llvm::pdb::PDBSymbolFunc &pdb_func);
 
-  bool ResolveFunction(llvm::pdb::PDBSymbolFunc *pdb_func,
+  bool ResolveFunction(const llvm::pdb::PDBSymbolFunc &pdb_func,
                        bool include_inlines,
                        lldb_private::SymbolContextList &sc_list);
 
   bool ResolveFunction(uint32_t uid, bool include_inlines,
                        lldb_private::SymbolContextList &sc_list);
 
   void CacheFunctionNames();
 

source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp

if (m_cached_compile_unit_count == 0) {
     std::string name = last_compiland_up->getName();
     if (name == "* Linker *")
       --m_cached_compile_unit_count;
   }
   return m_cached_compile_unit_count;
 }
 
 void SymbolFilePDB::GetCompileUnitIndex(
-    const llvm::pdb::PDBSymbolCompiland *pdb_compiland,
+    const llvm::pdb::PDBSymbolCompiland &pdb_compiland,
     uint32_t &index) {
-  if (!pdb_compiland)
-    return;
-
   auto results_up = m_global_scope_up->findAllChildren<PDBSymbolCompiland>();
   if (!results_up)
     return;
-  auto uid = pdb_compiland->getSymIndexId();
+  auto uid = pdb_compiland.getSymIndexId();
   for (uint32_t cu_idx = 0; cu_idx < GetNumCompileUnits(); ++cu_idx) {
     auto compiland_up = results_up->getChildAtIndex(cu_idx);
     if (!compiland_up)
       continue;
     if (compiland_up->getSymIndexId() == uid) {
       index = cu_idx;
       return;
     }
SymbolFilePDB::ParseCompileUnitLanguage(const lldb_private::SymbolContext &sc) {
   auto details = compiland_up->findOneChild<PDBSymbolCompilandDetails>();
   if (!details)
     return lldb::eLanguageTypeUnknown;
   return TranslateLanguage(details->getLanguage());
 }
 
 lldb_private::Function *
 SymbolFilePDB::ParseCompileUnitFunctionForPDBFunc(
-    const PDBSymbolFunc *pdb_func,
+    const PDBSymbolFunc &pdb_func,
     const lldb_private::SymbolContext &sc) {
-  assert(pdb_func != nullptr);
   lldbassert(sc.comp_unit && sc.module_sp.get());
 
-  auto file_vm_addr = pdb_func->getVirtualAddress();
+  auto file_vm_addr = pdb_func.getVirtualAddress();
   if (file_vm_addr == LLDB_INVALID_ADDRESS)
     return nullptr;
 
-  auto func_length = pdb_func->getLength();
+  auto func_length = pdb_func.getLength();
   AddressRange func_range = AddressRange(file_vm_addr,
                                          func_length,
                                          sc.module_sp->GetSectionList());
   if (!func_range.GetBaseAddress().IsValid())
     return nullptr;
 
-  lldb_private::Type* func_type = ResolveTypeUID(pdb_func->getSymIndexId());
+  lldb_private::Type* func_type = ResolveTypeUID(pdb_func.getSymIndexId());
   if (!func_type)
     return nullptr;
 
-  user_id_t func_type_uid = pdb_func->getSignatureId();
+  user_id_t func_type_uid = pdb_func.getSignatureId();
 
   Mangled mangled = GetMangledForPDBFunc(pdb_func);
 
   FunctionSP func_sp = std::make_shared<Function>(sc.comp_unit,
-                                                  pdb_func->getSymIndexId(),
+                                                  pdb_func.getSymIndexId(),
                                                   func_type_uid,
                                                   mangled,
                                                   func_type,
                                                   func_range);
 
   sc.comp_unit->AddFunction(func_sp);
   return func_sp.get();
 }
 
 size_t SymbolFilePDB::ParseCompileUnitFunctions(
     const lldb_private::SymbolContext &sc) {
   lldbassert(sc.comp_unit);
   size_t func_added = 0;
   auto compiland_up = GetPDBCompilandByUID(sc.comp_unit->GetID());
   if (!compiland_up)
     return 0;
   auto results_up = compiland_up->findAllChildren<PDBSymbolFunc>();
   if (!results_up)
     return 0;
   while (auto pdb_func_up = results_up->getNext()) {
     auto func_sp =
         sc.comp_unit->FindFunctionByUID(pdb_func_up->getSymIndexId());
     if (!func_sp) {
-      if (ParseCompileUnitFunctionForPDBFunc(pdb_func_up.get(), sc))
+      if (ParseCompileUnitFunctionForPDBFunc(*pdb_func_up, sc))
         ++func_added;
     }
   }
   return func_added;
 }
 
 bool SymbolFilePDB::ParseCompileUnitLineTable(
     const lldb_private::SymbolContext &sc) {
if (resolve_scope & eSymbolContextCompUnit ||
     switch (symbol_up->getSymTag()) {
     case PDB_SymType::Function:
       if (resolve_scope & eSymbolContextFunction) {
         auto *pdb_func = llvm::dyn_cast<PDBSymbolFunc>(symbol_up.get());
         assert(pdb_func);
         auto func_uid = pdb_func->getSymIndexId();
         sc.function = sc.comp_unit->FindFunctionByUID(func_uid).get();
         if (sc.function == nullptr)
-          sc.function = ParseCompileUnitFunctionForPDBFunc(pdb_func, sc);
+          sc.function = ParseCompileUnitFunctionForPDBFunc(*pdb_func, sc);
         if (sc.function) {
           resolved_flags |= eSymbolContextFunction;
           if (resolve_scope & eSymbolContextBlock) {
             Block &block = sc.function->GetBlock(true);
             sc.block = block.FindBlockByID(sc.function->GetID());
             if (sc.block)
               resolved_flags |= eSymbolContextBlock;
           }
while (auto compiland = compilands->getNext()) {
                 m_session_up->findSymbolByAddress(file_vm_addr,
                                                   PDB_SymType::Function);
             if (symbol_up) {
               auto func_uid = symbol_up->getSymIndexId();
               sc.function = sc.comp_unit->FindFunctionByUID(func_uid).get();
               if (sc.function == nullptr) {
                 auto pdb_func = llvm::dyn_cast<PDBSymbolFunc>(symbol_up.get());
                 assert(pdb_func);
-                sc.function = ParseCompileUnitFunctionForPDBFunc(pdb_func, sc);
+                sc.function = ParseCompileUnitFunctionForPDBFunc(*pdb_func, sc);
               }
               if (sc.function && (resolve_scope & eSymbolContextBlock)) {
                 Block &block = sc.function->GetBlock(true);
                 sc.block = block.FindBlockByID(sc.function->GetID());
               }
             }
             sc_list.Append(sc);
           }

 
 uint32_t
 SymbolFilePDB::FindGlobalVariables(const lldb_private::RegularExpression &regex,
                                    bool append, uint32_t max_matches,
                                    lldb_private::VariableList &variables) {
   return uint32_t();
 }
 
-bool SymbolFilePDB::ResolveFunction(llvm::pdb::PDBSymbolFunc *pdb_func,
+bool SymbolFilePDB::ResolveFunction(const llvm::pdb::PDBSymbolFunc &pdb_func,
                                     bool include_inlines,
                                     lldb_private::SymbolContextList &sc_list) {
-  if (!pdb_func)
-    return false;
   lldb_private::SymbolContext sc;
-  auto file_vm_addr = pdb_func->getVirtualAddress();
+  auto file_vm_addr = pdb_func.getVirtualAddress();
   if (file_vm_addr == LLDB_INVALID_ADDRESS)
     return false;
 
   Address so_addr(file_vm_addr);
   sc.comp_unit = GetCompileUnitContainsAddress(so_addr).get();
   if (!sc.comp_unit)
     return false;
   sc.module_sp = sc.comp_unit->GetModule();
   auto symbol_up =
       m_session_up->findSymbolByAddress(file_vm_addr, PDB_SymType::Function);
   if (!symbol_up)
     return false;
 
   auto *func = llvm::dyn_cast<PDBSymbolFunc>(symbol_up.get());
   assert(func);
-  sc.function = ParseCompileUnitFunctionForPDBFunc(func, sc);
+  sc.function = ParseCompileUnitFunctionForPDBFunc(*func, sc);
   if (!sc.function)
     return false;
 
   sc_list.Append(sc);
   return true;
 }
 
 bool SymbolFilePDB::ResolveFunction(uint32_t uid, bool include_inlines,
                                     lldb_private::SymbolContextList &sc_list) {
   auto pdb_func_up =
       m_session_up->getConcreteSymbolById<PDBSymbolFunc>(uid);
   if (!pdb_func_up && !(include_inlines && pdb_func_up->hasInlineAttribute()))
     return false;
-  return ResolveFunction(pdb_func_up.get(), include_inlines, sc_list);
+  return ResolveFunction(*pdb_func_up, include_inlines, sc_list);
 }
 
 void SymbolFilePDB::CacheFunctionNames() {
   if (!m_func_full_names.IsEmpty())
     return;
 
   std::map<uint64_t, uint32_t> addr_ids;
 
size_t SymbolFilePDB::FindTypes(
   return 0;
 }
 
 lldb_private::TypeList *SymbolFilePDB::GetTypeList() {
   return m_obj_file->GetModule()->GetTypeList();
 }
 
 void
-SymbolFilePDB::GetTypesForPDBSymbol(const llvm::pdb::PDBSymbol *pdb_symbol,
+SymbolFilePDB::GetTypesForPDBSymbol(const llvm::pdb::PDBSymbol &pdb_symbol,
                                     uint32_t type_mask,
                                     TypeCollection &type_collection) {
-  if (!pdb_symbol)
-    return;
-
   bool can_parse = false;
-  switch (pdb_symbol->getSymTag()) {
+  switch (pdb_symbol.getSymTag()) {
   case PDB_SymType::ArrayType:
     can_parse = ((type_mask & eTypeClassArray) != 0);
     break;
   case PDB_SymType::BuiltinType:
     can_parse = ((type_mask & eTypeClassBuiltin) != 0);
     break;
   case PDB_SymType::Enum:
     can_parse = ((type_mask & eTypeClassEnumeration) != 0);
     break;
   case PDB_SymType::Function:
   case PDB_SymType::FunctionSig:
     can_parse = ((type_mask & eTypeClassFunction) != 0);
     break;
   case PDB_SymType::PointerType:
     can_parse = ((type_mask & (eTypeClassPointer | eTypeClassBlockPointer |
                                eTypeClassMemberPointer)) != 0);
     break;
   case PDB_SymType::Typedef:
     can_parse = ((type_mask & eTypeClassTypedef) != 0);
     break;
   case PDB_SymType::UDT: {
-    auto *udt = llvm::dyn_cast<PDBSymbolTypeUDT>(pdb_symbol);
+    auto *udt = llvm::dyn_cast<PDBSymbolTypeUDT>(&pdb_symbol);
     assert(udt);
     can_parse = (udt->getUdtKind() != PDB_UdtType::Interface &&
         ((type_mask & (eTypeClassClass | eTypeClassStruct |
                        eTypeClassUnion)) != 0));
   } break;
   default:break;
   }
 
   if (can_parse) {
-    if (auto *type = ResolveTypeUID(pdb_symbol->getSymIndexId())) {
+    if (auto *type = ResolveTypeUID(pdb_symbol.getSymIndexId())) {
       auto result =
           std::find(type_collection.begin(), type_collection.end(), type);
       if (result == type_collection.end())
         type_collection.push_back(type);
     }
   }
 
-  auto results_up = pdb_symbol->findAllChildren();
+  auto results_up = pdb_symbol.findAllChildren();
   while (auto symbol_up = results_up->getNext())
-    GetTypesForPDBSymbol(symbol_up.get(), type_mask, type_collection);
+    GetTypesForPDBSymbol(*symbol_up, type_mask, type_collection);
 }
 
 size_t SymbolFilePDB::GetTypes(lldb_private::SymbolContextScope *sc_scope,
                                uint32_t type_mask,
                                lldb_private::TypeList &type_list) {
   TypeCollection type_collection;
   uint32_t old_size = type_list.GetSize();
   CompileUnit *cu = sc_scope ?
       sc_scope->CalculateSymbolContextCompileUnit() : nullptr;
   if (cu) {
     auto compiland_up = GetPDBCompilandByUID(cu->GetID());
-    GetTypesForPDBSymbol(compiland_up.get(), type_mask, type_collection);
+    if (!compiland_up)
+      return 0;
+    GetTypesForPDBSymbol(*compiland_up, type_mask, type_collection);
   } else {
     for (uint32_t cu_idx = 0; cu_idx < GetNumCompileUnits(); ++cu_idx) {
       auto cu_sp = ParseCompileUnitAtIndex(cu_idx);
       if (cu_sp.get()) {
-        auto compiland_up = GetPDBCompilandByUID(cu_sp->GetID());
-        GetTypesForPDBSymbol(compiland_up.get(), type_mask, type_collection);
+        if (auto compiland_up = GetPDBCompilandByUID(cu_sp->GetID()))
+          GetTypesForPDBSymbol(*compiland_up, type_mask, type_collection);
       }
     }
   }
 
   for (auto type : type_collection) {
     type->GetForwardCompilerType();
     type_list.Insert(type->shared_from_this());
   }
SymbolFilePDB::ParseCompileUnitForUID(uint32_t id, uint32_t index) {
   auto cu_sp = std::make_shared<CompileUnit>(
       m_obj_file->GetModule(), nullptr, path.c_str(), id, lang, optimized);
 
   if (!cu_sp)
     return CompUnitSP();
 
   m_comp_units.insert(std::make_pair(id, cu_sp));
   if (index == UINT32_MAX)
-    GetCompileUnitIndex(compiland_up.get(), index);
+    GetCompileUnitIndex(*compiland_up, index);
   lldbassert(index != UINT32_MAX);
   m_obj_file->GetModule()->GetSymbolVendor()->SetCompileUnitAtIndex(
       index, cu_sp);
   return cu_sp;
 }
 
 bool SymbolFilePDB::ParseCompileUnitLineTable(
     const lldb_private::SymbolContext &sc, uint32_t match_line) {
lldb::CompUnitSP SymbolFilePDB::GetCompileUnitContainsAddress(
   if (compiland_up) {
     return ParseCompileUnitForUID(compiland_up->getSymIndexId());
   }
 
   return nullptr;
 }
 
 Mangled
-SymbolFilePDB::GetMangledForPDBFunc(const llvm::pdb::PDBSymbolFunc *pdb_func) {
+SymbolFilePDB::GetMangledForPDBFunc(const llvm::pdb::PDBSymbolFunc &pdb_func) {
   Mangled mangled;
-  if (!pdb_func)
-    return mangled;
-
-  auto func_name = pdb_func->getName();
-  auto func_undecorated_name = pdb_func->getUndecoratedName();
+  auto func_name = pdb_func.getName();
+  auto func_undecorated_name = pdb_func.getUndecoratedName();
   std::string func_decorated_name;
 
   // Seek from public symbols for non-static function's decorated name if any.
   // For static functions, they don't have undecorated names and aren't exposed
   // in Public Symbols either.
   if (!func_undecorated_name.empty()) {
     auto result_up =
         m_global_scope_up->findChildren(PDB_SymType::PublicSymbol,