[lldb][NFC] Make all CompilerDeclContext parameters references instead of pointers

[teemperor]

Summary

All of our lookup APIs either use CompilerDeclContext & or CompilerDeclContext * semi-randomly it seems.
This leads to us constantly converting between those two types (and doing nullptr checks when going from
pointer to reference). It also leads to the confusing situation where we have two possible ways to express
that we don't have a CompilerDeclContex: either a nullptr or an invalid CompilerDeclContext (aka a default
constructed CompilerDeclContext).

This moves all APIs to use references and gets rid of all the nullptr checks and conversions.

[labath]

Yes, please.

Bonus points to anyone who can replace the default-constructed CompilerDeclContext with llvm::None.

[shafik]

This is a great change, it makes the code more consistent. LGTM besides the few comments I made.

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

1133

!parent_decl_ctx.IsValid() && GetDeclContextContainingUID(result->getSymIndexId()) != parent_decl_ctx seems like a more accurate replacement especially if GetDeclContextContainingUID can also return an invalid result, I think.

1326

Same comment as above.

1549

same here.

[teemperor]

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

1133

I think the negation at the start is a typo? With the negation it would mean that with a valid parent_decl_ctx the continue would never be evaluated. But the intend seems to be to only parse variables that are in the DeclContext. So with the negation, specifying any parent_decl_ctxwould disable the filter and we would parse all variables in all DeclContexts?

But yeah, I think this makes sense. In theory DeclContextMatchesThisSymbolFile seems to early-exit on the error cases that would cause GetDeclContextContainingUID to return an invalid DeclContext and the function has an assert for an valid result at the end, but I think the IPDBSession error case could return an invalid DeclContext in this function. Let's just play safe and keep the check.

[teemperor]

• Readded some parent_decl_context.IsValid() checks to SymbolFilePDB

lldb/include/lldb/Core/Module.h

public:
   ///     be used when doing the lookup. Bits include fully qualified
   ///     names, base names, C++ methods, or ObjC selectors.
   ///     See FunctionNameType for more details.
   ///
   /// \param[out] sc_list
   ///     A symbol context list that gets filled in with all of the
   ///     matches.
   void FindFunctions(ConstString name,
-                     const CompilerDeclContext *parent_decl_ctx,
+                     const CompilerDeclContext &parent_decl_ctx,
                      lldb::FunctionNameType name_type_mask, bool symbols_ok,
                      bool inlines_ok, SymbolContextList &sc_list);
 
   /// Find functions by name.
   ///
   /// If the function is an inlined function, it will have a block,
   /// representing the inlined function, and the function will be the
   /// containing function.  If it is not inlined, then the block will be NULL.
public:
   /// \param[in] max_matches
   ///     Allow the number of matches to be limited to \a
   ///     max_matches. Specify UINT32_MAX to get all possible matches.
   ///
   /// \param[in] variable_list
   ///     A list of variables that gets the matches appended to.
   ///
   void FindGlobalVariables(ConstString name,
-                           const CompilerDeclContext *parent_decl_ctx,
+                           const CompilerDeclContext &parent_decl_ctx,
                            size_t max_matches, VariableList &variable_list);
 
   /// Find global and static variables by regular expression.
   ///
   /// \param[in] regex
   ///     A regular expression to use when matching the name.
   ///
   /// \param[in] max_matches
public:
   ///
   /// \param[in] type_name
   ///     The name of a type within a namespace that should not include
   ///     any qualifying namespaces (just a type basename).
   ///
   /// \param[out] type_list
   ///     A type list gets populated with any matches.
   void FindTypesInNamespace(ConstString type_name,
-                            const CompilerDeclContext *parent_decl_ctx,
+                            const CompilerDeclContext &parent_decl_ctx,
                             size_t max_matches, TypeList &type_list);
 
   /// Get const accessor for the module architecture.
   ///
   /// \return
   ///     A const reference to the architecture object.
   const ArchSpec &GetArchitecture() const;
 
protected:
   friend class ModuleList;
   friend class ObjectFile;
   friend class SymbolFile;
 
 private:
   Module(); // Only used internally by CreateJITModule ()
 
   void FindTypes_Impl(
-      ConstString name, const CompilerDeclContext *parent_decl_ctx,
+      ConstString name, const CompilerDeclContext &parent_decl_ctx,
       size_t max_matches,
       llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
       TypeMap &types);
 
   DISALLOW_COPY_AND_ASSIGN(Module);
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_Module_h_

lldb/include/lldb/Symbol/SymbolFile.h

virtual uint32_t ResolveSymbolContext(const Address &so_addr,
                                         lldb::SymbolContextItem resolve_scope,
                                         SymbolContext &sc) = 0;
   virtual uint32_t ResolveSymbolContext(const FileSpec &file_spec,
                                         uint32_t line, bool check_inlines,
                                         lldb::SymbolContextItem resolve_scope,
                                         SymbolContextList &sc_list);
 
   virtual void DumpClangAST(Stream &s) {}
-  virtual void
-  FindGlobalVariables(ConstString name,
-                      const CompilerDeclContext *parent_decl_ctx,
-                      uint32_t max_matches, VariableList &variables);
+  virtual void FindGlobalVariables(ConstString name,
+                                   const CompilerDeclContext &parent_decl_ctx,
+                                   uint32_t max_matches,
+                                   VariableList &variables);
   virtual void FindGlobalVariables(const RegularExpression &regex,
                                    uint32_t max_matches,
                                    VariableList &variables);
   virtual void FindFunctions(ConstString name,
-                             const CompilerDeclContext *parent_decl_ctx,
+                             const CompilerDeclContext &parent_decl_ctx,
                              lldb::FunctionNameType name_type_mask,
                              bool include_inlines, SymbolContextList &sc_list);
   virtual void FindFunctions(const RegularExpression &regex,
                              bool include_inlines, SymbolContextList &sc_list);
   virtual void
-  FindTypes(ConstString name, const CompilerDeclContext *parent_decl_ctx,
+  FindTypes(ConstString name, const CompilerDeclContext &parent_decl_ctx,
             uint32_t max_matches,
             llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
             TypeMap &types);
 
   /// Find types specified by a CompilerContextPattern.
   /// \param languages
   ///     Only return results in these languages.
   /// \param searched_symbol_files
virtual void GetTypes(lldb_private::SymbolContextScope *sc_scope,
                         lldb_private::TypeList &type_list) = 0;
 
   virtual void PreloadSymbols();
 
   virtual llvm::Expected<lldb_private::TypeSystem &>
   GetTypeSystemForLanguage(lldb::LanguageType language);
 
   virtual CompilerDeclContext
-  FindNamespace(ConstString name,
-                const CompilerDeclContext *parent_decl_ctx) {
+  FindNamespace(ConstString name, const CompilerDeclContext &parent_decl_ctx) {
     return CompilerDeclContext();
   }
 
   ObjectFile *GetObjectFile() { return m_objfile_sp.get(); }
   const ObjectFile *GetObjectFile() const { return m_objfile_sp.get(); }
   ObjectFile *GetMainObjectFile();
 
   virtual std::vector<std::unique_ptr<CallEdge>>

lldb/source/API/SBModule.cpp

LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBModule, FindFunctions,
                      (const char *, uint32_t), name, name_type_mask);
 
   lldb::SBSymbolContextList sb_sc_list;
   ModuleSP module_sp(GetSP());
   if (name && module_sp) {
     const bool symbols_ok = true;
     const bool inlines_ok = true;
     FunctionNameType type = static_cast<FunctionNameType>(name_type_mask);
-    module_sp->FindFunctions(ConstString(name), nullptr, type, symbols_ok,
-                             inlines_ok, *sb_sc_list);
+    module_sp->FindFunctions(ConstString(name), CompilerDeclContext(), type,
+                             symbols_ok, inlines_ok, *sb_sc_list);
   }
   return LLDB_RECORD_RESULT(sb_sc_list);
 }
 
 SBValueList SBModule::FindGlobalVariables(SBTarget &target, const char *name,
                                           uint32_t max_matches) {
   LLDB_RECORD_METHOD(lldb::SBValueList, SBModule, FindGlobalVariables,
                      (lldb::SBTarget &, const char *, uint32_t), target, name,
                      max_matches);
 
   SBValueList sb_value_list;
   ModuleSP module_sp(GetSP());
   if (name && module_sp) {
     VariableList variable_list;
-    module_sp->FindGlobalVariables(ConstString(name), nullptr, max_matches,
-                                   variable_list);
+    module_sp->FindGlobalVariables(ConstString(name), CompilerDeclContext(),
+                                   max_matches, variable_list);
     for (const VariableSP &var_sp : variable_list) {
       lldb::ValueObjectSP valobj_sp;
       TargetSP target_sp(target.GetSP());
       valobj_sp = ValueObjectVariable::Create(target_sp.get(), var_sp);
       if (valobj_sp)
         sb_value_list.Append(SBValue(valobj_sp));
     }
   }

lldb/source/Breakpoint/BreakpointResolverName.cpp

BreakpointResolverName::SearchCallback(SearchFilter &filter,
   const bool include_inlines = true;
 
   switch (m_match_type) {
   case Breakpoint::Exact:
     if (context.module_sp) {
       for (const auto &lookup : m_lookups) {
         const size_t start_func_idx = func_list.GetSize();
         context.module_sp->FindFunctions(
-            lookup.GetLookupName(), nullptr, lookup.GetNameTypeMask(),
-            include_symbols, include_inlines, func_list);
+            lookup.GetLookupName(), CompilerDeclContext(),
+            lookup.GetNameTypeMask(), include_symbols, include_inlines,
+            func_list);
 
         const size_t end_func_idx = func_list.GetSize();
 
         if (start_func_idx < end_func_idx)
           lookup.Prune(func_list, start_func_idx);
       }
     }
     break;

lldb/source/Commands/CommandObjectTarget.cpp

if (module && name && name[0]) {
     SymbolContextList sc_list;
     size_t num_matches = 0;
     if (name_is_regex) {
       RegularExpression function_name_regex((llvm::StringRef(name)));
       module->FindFunctions(function_name_regex, include_symbols,
                             include_inlines, sc_list);
     } else {
       ConstString function_name(name);
-      module->FindFunctions(function_name, nullptr, eFunctionNameTypeAuto,
-                            include_symbols, include_inlines, sc_list);
+      module->FindFunctions(function_name, CompilerDeclContext(),
+                            eFunctionNameTypeAuto, include_symbols,
+                            include_inlines, sc_list);
     }
     num_matches = sc_list.GetSize();
     if (num_matches) {
       strm.Indent();
       strm.Printf("%" PRIu64 " match%s found in ", (uint64_t)num_matches,
                   num_matches > 1 ? "es" : "");
       DumpFullpath(strm, &module->GetFileSpec(), 0);
       strm.PutCString(":\n");

lldb/source/Core/AddressResolverName.cpp

AddressResolverName::SearchCallback(SearchFilter &filter,
 
   const bool include_symbols = false;
   const bool include_inlines = true;
   switch (m_match_type) {
   case AddressResolver::Exact:
     if (context.module_sp) {
       context.module_sp->FindSymbolsWithNameAndType(m_func_name,
                                                     eSymbolTypeCode, sym_list);
-      context.module_sp->FindFunctions(m_func_name, nullptr,
+      context.module_sp->FindFunctions(m_func_name, CompilerDeclContext(),
                                        eFunctionNameTypeAuto, include_symbols,
                                        include_inlines, func_list);
     }
     break;
 
   case AddressResolver::Regexp:
     if (context.module_sp) {
       context.module_sp->FindSymbolsMatchingRegExAndType(

lldb/source/Core/Disassembler.cpp

if (!name)
     return false;
 
   const bool include_symbols = true;
   const bool include_inlines = true;
 
   // Find functions matching the given name.
   SymbolContextList sc_list;
   if (module) {
-    module->FindFunctions(name, nullptr, eFunctionNameTypeAuto, include_symbols,
-                          include_inlines, sc_list);
+    module->FindFunctions(name, CompilerDeclContext(), eFunctionNameTypeAuto,
+                          include_symbols, include_inlines, sc_list);
   } else if (exe_ctx.GetTargetPtr()) {
     exe_ctx.GetTargetPtr()->GetImages().FindFunctions(
         name, eFunctionNameTypeAuto, include_symbols, include_inlines, sc_list);
   }
 
   // If no functions were found there's nothing to disassemble.
   if (sc_list.IsEmpty())
     return false;

lldb/source/Core/Module.cpp

uint32_t Module::ResolveSymbolContextsForFileSpec(
   if (SymbolFile *symbols = GetSymbolFile())
     symbols->ResolveSymbolContext(file_spec, line, check_inlines, resolve_scope,
                                   sc_list);
 
   return sc_list.GetSize() - initial_count;
 }
 
 void Module::FindGlobalVariables(ConstString name,
-                                 const CompilerDeclContext *parent_decl_ctx,
+                                 const CompilerDeclContext &parent_decl_ctx,
                                  size_t max_matches, VariableList &variables) {
   if (SymbolFile *symbols = GetSymbolFile())
     symbols->FindGlobalVariables(name, parent_decl_ctx, max_matches, variables);
 }
 
 void Module::FindGlobalVariables(const RegularExpression &regex,
                                  size_t max_matches, VariableList &variables) {
   SymbolFile *symbols = GetSymbolFile();
while (i < sc_list.GetSize()) {
         }
       }
       ++i;
     }
   }
 }
 
 void Module::FindFunctions(ConstString name,
-                           const CompilerDeclContext *parent_decl_ctx,
+                           const CompilerDeclContext &parent_decl_ctx,
                            FunctionNameType name_type_mask,
                            bool include_symbols, bool include_inlines,
                            SymbolContextList &sc_list) {
   const size_t old_size = sc_list.GetSize();
 
   // Find all the functions (not symbols, but debug information functions...
   SymbolFile *symbols = GetSymbolFile();
 
for (size_t n = 0; n < resolver.GetNumberOfAddresses(); n++) {
     if (f && f == function)
       output_local.push_back(addr);
     else
       output_extern.push_back(addr);
   }
 }
 
 void Module::FindTypes_Impl(
-    ConstString name, const CompilerDeclContext *parent_decl_ctx,
+    ConstString name, const CompilerDeclContext &parent_decl_ctx,
     size_t max_matches,
     llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
     TypeMap &types) {
   static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
   Timer scoped_timer(func_cat, LLVM_PRETTY_FUNCTION);
   if (SymbolFile *symbols = GetSymbolFile())
     symbols->FindTypes(name, parent_decl_ctx, max_matches,
                        searched_symbol_files, types);
 }
 
 void Module::FindTypesInNamespace(ConstString type_name,
-                                  const CompilerDeclContext *parent_decl_ctx,
+                                  const CompilerDeclContext &parent_decl_ctx,
                                   size_t max_matches, TypeList &type_list) {
   TypeMap types_map;
   llvm::DenseSet<lldb_private::SymbolFile *> searched_symbol_files;
   FindTypes_Impl(type_name, parent_decl_ctx, max_matches, searched_symbol_files,
                  types_map);
   if (types_map.GetSize()) {
     SymbolContext sc;
     sc.module_sp = shared_from_this();
if (Type::GetTypeScopeAndBasename(type_name_cstr, type_scope, type_basename,
                                     type_class)) {
     // Check if "name" starts with "::" which means the qualified type starts
     // from the root namespace and implies and exact match. The typenames we
     // get back from clang do not start with "::" so we need to strip this off
     // in order to get the qualified names to match
     exact_match = type_scope.consume_front("::");
 
     ConstString type_basename_const_str(type_basename);
-    FindTypes_Impl(type_basename_const_str, nullptr, max_matches,
+    FindTypes_Impl(type_basename_const_str, CompilerDeclContext(), max_matches,
                    searched_symbol_files, typesmap);
     if (typesmap.GetSize())
       typesmap.RemoveMismatchedTypes(std::string(type_scope),
                                      std::string(type_basename), type_class,
                                      exact_match);
   } else {
     // The type is not in a namespace/class scope, just search for it by
     // basename
     if (type_class != eTypeClassAny && !type_basename.empty()) {
       // The "type_name_cstr" will have been modified if we have a valid type
       // class prefix (like "struct", "class", "union", "typedef" etc).
-      FindTypes_Impl(ConstString(type_basename), nullptr, UINT_MAX,
-                     searched_symbol_files, typesmap);
+      FindTypes_Impl(ConstString(type_basename), CompilerDeclContext(),
+                     UINT_MAX, searched_symbol_files, typesmap);
       typesmap.RemoveMismatchedTypes(std::string(type_scope),
                                      std::string(type_basename), type_class,
                                      exact_match);
     } else {
-      FindTypes_Impl(name, nullptr, UINT_MAX, searched_symbol_files, typesmap);
+      FindTypes_Impl(name, CompilerDeclContext(), UINT_MAX,
+                     searched_symbol_files, typesmap);
       if (exact_match) {
         std::string name_str(name.AsCString(""));
         typesmap.RemoveMismatchedTypes(std::string(type_scope), name_str,
                                        type_class, exact_match);
       }
     }
   }
   if (typesmap.GetSize()) {

lldb/source/Core/ModuleList.cpp

void ModuleList::FindFunctions(ConstString name,
   const size_t old_size = sc_list.GetSize();
 
   if (name_type_mask & eFunctionNameTypeAuto) {
     Module::LookupInfo lookup_info(name, name_type_mask, eLanguageTypeUnknown);
 
     std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
     collection::const_iterator pos, end = m_modules.end();
     for (pos = m_modules.begin(); pos != end; ++pos) {
-      (*pos)->FindFunctions(lookup_info.GetLookupName(), nullptr,
+      (*pos)->FindFunctions(lookup_info.GetLookupName(), CompilerDeclContext(),
                             lookup_info.GetNameTypeMask(), include_symbols,
                             include_inlines, sc_list);
     }
 
     const size_t new_size = sc_list.GetSize();
 
     if (old_size < new_size)
       lookup_info.Prune(sc_list, old_size);
   } else {
     std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
     collection::const_iterator pos, end = m_modules.end();
     for (pos = m_modules.begin(); pos != end; ++pos) {
-      (*pos)->FindFunctions(name, nullptr, name_type_mask, include_symbols,
-                            include_inlines, sc_list);
+      (*pos)->FindFunctions(name, CompilerDeclContext(), name_type_mask,
+                            include_symbols, include_inlines, sc_list);
     }
   }
 }
 
 void ModuleList::FindFunctionSymbols(ConstString name,
                                      lldb::FunctionNameType name_type_mask,
                                      SymbolContextList &sc_list) {
   const size_t old_size = sc_list.GetSize();
void ModuleList::FindCompileUnits(const FileSpec &path,
   }
 }
 
 void ModuleList::FindGlobalVariables(ConstString name, size_t max_matches,
                                      VariableList &variable_list) const {
   std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
   collection::const_iterator pos, end = m_modules.end();
   for (pos = m_modules.begin(); pos != end; ++pos) {
-    (*pos)->FindGlobalVariables(name, nullptr, max_matches, variable_list);
+    (*pos)->FindGlobalVariables(name, CompilerDeclContext(), max_matches,
+                                variable_list);
   }
 }
 
 void ModuleList::FindGlobalVariables(const RegularExpression &regex,
                                      size_t max_matches,
                                      VariableList &variable_list) const {
   std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
   collection::const_iterator pos, end = m_modules.end();

lldb/source/Core/SourceManager.cpp

if (target_sp) {
       // Otherwise, if we can't find it we won't look again, somebody will have
       // to set it (for instance when we stop somewhere...)
       Module *executable_ptr = target_sp->GetExecutableModulePointer();
       if (executable_ptr) {
         SymbolContextList sc_list;
         ConstString main_name("main");
         bool symbols_okay = false; // Force it to be a debug symbol.
         bool inlines_okay = true;
-        executable_ptr->FindFunctions(main_name, nullptr,
+        executable_ptr->FindFunctions(main_name, CompilerDeclContext(),
                                       lldb::eFunctionNameTypeBase, inlines_okay,
                                       symbols_okay, sc_list);
         size_t num_matches = sc_list.GetSize();
         for (size_t idx = 0; idx < num_matches; idx++) {
           SymbolContext sc;
           sc_list.GetContextAtIndex(idx, sc);
           if (sc.function) {
             lldb_private::LineEntry line_entry;

lldb/source/Expression/IRExecutionUnit.cpp

std::function<bool(lldb::addr_t &, SymbolContextList &,
         load_address = 0;
         return true;
       }
       
       return false;
     };
 
     if (sc.module_sp) {
-      sc.module_sp->FindFunctions(spec.name, nullptr, spec.mask,
+      sc.module_sp->FindFunctions(spec.name, CompilerDeclContext(), spec.mask,
                                   true,  // include_symbols
                                   false, // include_inlines
                                   sc_list);
     }
 
     lldb::addr_t load_address = LLDB_INVALID_ADDRESS;
 
     if (get_external_load_address(load_address, sc_list, sc)) {

lldb/source/Plugins/ExpressionParser/Clang/ClangASTSource.cpp

if (const NamespaceDecl *namespace_context =
         LLDB_LOG(log, "      CTD[{0}] Searching namespace {1} in module {2}",
                  current_id, i->second.GetName(),
                  i->first->GetFileSpec().GetFilename());
 
         TypeList types;
 
         ConstString name(tag_decl->getName().str().c_str());
 
-        i->first->FindTypesInNamespace(name, &i->second, UINT32_MAX, types);
+        i->first->FindTypesInNamespace(name, i->second, UINT32_MAX, types);
 
         for (uint32_t ti = 0, te = types.GetSize(); ti != te && !found; ++ti) {
           lldb::TypeSP type = types.GetTypeAtIndex(ti);
 
           if (!type)
             continue;
 
           CompilerType clang_type(type->GetFullCompilerType());
void ClangASTSource::FindExternalVisibleDecls(
 
   if (!m_target)
     return;
 
   if (module_sp && namespace_decl) {
     CompilerDeclContext found_namespace_decl;
 
     if (SymbolFile *symbol_file = module_sp->GetSymbolFile()) {
-      found_namespace_decl = symbol_file->FindNamespace(name, &namespace_decl);
+      found_namespace_decl = symbol_file->FindNamespace(name, namespace_decl);
 
       if (found_namespace_decl) {
         context.m_namespace_map->push_back(
             std::pair<lldb::ModuleSP, CompilerDeclContext>(
                 module_sp, found_namespace_decl));
 
         LLDB_LOG(log, "  CAS::FEVD[{0}] Found namespace {1} in module {2}",
                  current_id, name, module_sp->GetFileSpec().GetFilename());
for (size_t i = 0, e = target_images.GetSize(); i < e; ++i) {
 
       CompilerDeclContext found_namespace_decl;
 
       SymbolFile *symbol_file = image->GetSymbolFile();
 
       if (!symbol_file)
         continue;
 
-      found_namespace_decl = symbol_file->FindNamespace(name, &namespace_decl);
+      found_namespace_decl = symbol_file->FindNamespace(name, namespace_decl);
 
       if (found_namespace_decl) {
         context.m_namespace_map->push_back(
             std::pair<lldb::ModuleSP, CompilerDeclContext>(
                 image, found_namespace_decl));
 
         LLDB_LOG(log, "  CAS::FEVD[{0}] Found namespace {1} in module {2}",
                  current_id, name, image->GetFileSpec().GetFilename());
       }
     }
   }
 
   do {
     if (context.m_found.type)
       break;
 
     TypeList types;
     const bool exact_match = true;
     llvm::DenseSet<lldb_private::SymbolFile *> searched_symbol_files;
     if (module_sp && namespace_decl)
-      module_sp->FindTypesInNamespace(name, &namespace_decl, 1, types);
+      module_sp->FindTypesInNamespace(name, namespace_decl, 1, types);
     else {
       m_target->GetImages().FindTypes(module_sp.get(), name, exact_match, 1,
                                       searched_symbol_files, types);
     }
 
     if (size_t num_types = types.GetSize()) {
       for (size_t ti = 0; ti < num_types; ++ti) {
         lldb::TypeSP type_sp = types.GetTypeAtIndex(ti);
for (ClangASTImporter::NamespaceMap::iterator i = parent_map->begin(),
       CompilerDeclContext module_parent_namespace_decl = i->second;
 
       SymbolFile *symbol_file = module_sp->GetSymbolFile();
 
       if (!symbol_file)
         continue;
 
       found_namespace_decl =
-          symbol_file->FindNamespace(name, &module_parent_namespace_decl);
+          symbol_file->FindNamespace(name, module_parent_namespace_decl);
 
       if (!found_namespace_decl)
         continue;
 
       namespace_map->push_back(std::pair<lldb::ModuleSP, CompilerDeclContext>(
           module_sp, found_namespace_decl));
 
       LLDB_LOG(log, "  CMN[{0}] Found namespace {1} in module {2}", current_id,
for (size_t i = 0, e = target_images.GetSize(); i < e; ++i) {
       CompilerDeclContext found_namespace_decl;
 
       SymbolFile *symbol_file = image->GetSymbolFile();
 
       if (!symbol_file)
         continue;
 
       found_namespace_decl =
-          symbol_file->FindNamespace(name, &null_namespace_decl);
+          symbol_file->FindNamespace(name, null_namespace_decl);
 
       if (!found_namespace_decl)
         continue;
 
       namespace_map->push_back(std::pair<lldb::ModuleSP, CompilerDeclContext>(
           image, found_namespace_decl));
 
       LLDB_LOG(log, "  CMN[{0}] Found namespace {1} in module {2}", current_id,

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp

 }
 
 lldb::VariableSP ClangExpressionDeclMap::FindGlobalVariable(
     Target &target, ModuleSP &module, ConstString name,
     CompilerDeclContext *namespace_decl) {
   VariableList vars;
 
   if (module && namespace_decl)
-    module->FindGlobalVariables(name, namespace_decl, -1, vars);
+    module->FindGlobalVariables(name, *namespace_decl, -1, vars);
   else
     target.GetImages().FindGlobalVariables(name, -1, vars);
 
   if (vars.GetSize() == 0)
     return VariableSP();
   return vars.GetVariableAtIndex(0);
 }
 
if (target) {
     }
   }
 
   const bool include_inlines = false;
   SymbolContextList sc_list;
   if (namespace_decl && module_sp) {
     const bool include_symbols = false;
 
-    module_sp->FindFunctions(name, &namespace_decl, eFunctionNameTypeBase,
+    module_sp->FindFunctions(name, namespace_decl, eFunctionNameTypeBase,
                              include_symbols, include_inlines, sc_list);
   } else if (target && !namespace_decl) {
     const bool include_symbols = true;
 
     // TODO Fix FindFunctions so that it doesn't return
     //   instance methods for eFunctionNameTypeBase.
 
     target->GetImages().FindFunctions(

lldb/source/Plugins/InstrumentationRuntime/TSan/InstrumentationRuntimeTSan.cpp

static void GetSymbolDeclarationFromAddress(ProcessSP process_sp, addr_t addr,
 
   ConstString sym_name = symbol->GetMangled().GetName(Mangled::ePreferMangled);
 
   ModuleSP module = symbol->CalculateSymbolContextModule();
   if (!module)
     return;
 
   VariableList var_list;
-  module->FindGlobalVariables(sym_name, nullptr, 1U, var_list);
+  module->FindGlobalVariables(sym_name, CompilerDeclContext(), 1U, var_list);
   if (var_list.GetSize() < 1)
     return;
 
   VariableSP var = var_list.GetVariableAtIndex(0);
   decl = var->GetDeclaration();
 }
 
 addr_t InstrumentationRuntimeTSan::GetFirstNonInternalFramePc(

lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp

void RSModuleDescriptor::Dump(Stream &strm) const {
   }
 
   strm.SetIndentLevel(indent);
 }
 
 void RSGlobalDescriptor::Dump(Stream &strm) const {
   strm.Indent(m_name.GetStringRef());
   VariableList var_list;
-  m_module->m_module->FindGlobalVariables(m_name, nullptr, 1U, var_list);
+  m_module->m_module->FindGlobalVariables(m_name, CompilerDeclContext(), 1U,
+                                          var_list);
   if (var_list.GetSize() == 1) {
     auto var = var_list.GetVariableAtIndex(0);
     auto type = var->GetType();
     if (type) {
       strm.Printf(" - ");
       type->DumpTypeName(&strm);
     } else {
       strm.Printf(" - Unknown Type");

lldb/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.h

bool ParseImportedModules(
       const SymbolContext &sc,
       std::vector<lldb_private::SourceModule> &imported_modules) override {
     return false;
   }
 
   size_t ParseBlocksRecursive(Function &func) override { return 0; }
 
   void FindGlobalVariables(ConstString name,
-                           const CompilerDeclContext *parent_decl_ctx,
+                           const CompilerDeclContext &parent_decl_ctx,
                            uint32_t max_matches,
                            VariableList &variables) override {}
 
   size_t ParseVariablesForContext(const SymbolContext &sc) override {
     return 0;
   }
   Type *ResolveTypeUID(lldb::user_id_t type_uid) override { return nullptr; }
   llvm::Optional<ArrayInfo> GetDynamicArrayInfoForUID(
uint32_t ResolveSymbolContext(const FileSpec &file_spec, uint32_t line,
                                 bool check_inlines,
                                 lldb::SymbolContextItem resolve_scope,
                                 SymbolContextList &sc_list) override;
 
   void GetTypes(SymbolContextScope *sc_scope, lldb::TypeClass type_mask,
                 TypeList &type_list) override {}
 
   void FindFunctions(ConstString name,
-                     const CompilerDeclContext *parent_decl_ctx,
+                     const CompilerDeclContext &parent_decl_ctx,
                      lldb::FunctionNameType name_type_mask,
                      bool include_inlines, SymbolContextList &sc_list) override;
 
   void FindFunctions(const RegularExpression &regex, bool include_inlines,
                      SymbolContextList &sc_list) override;
 
-  void FindTypes(ConstString name, const CompilerDeclContext *parent_decl_ctx,
+  void FindTypes(ConstString name, const CompilerDeclContext &parent_decl_ctx,
                  uint32_t max_matches,
                  llvm::DenseSet<SymbolFile *> &searched_symbol_files,
                  TypeMap &types) override;
 
   void FindTypes(llvm::ArrayRef<CompilerContext> pattern, LanguageSet languages,
                  llvm::DenseSet<SymbolFile *> &searched_symbol_files,
                  TypeMap &types) override;
 
   llvm::Expected<TypeSystem &>
   GetTypeSystemForLanguage(lldb::LanguageType language) override {
     return llvm::make_error<llvm::StringError>(
         "SymbolFileBreakpad does not support GetTypeSystemForLanguage",
         llvm::inconvertibleErrorCode());
   }
 
   CompilerDeclContext
   FindNamespace(ConstString name,
-                const CompilerDeclContext *parent_decl_ctx) override {
+                const CompilerDeclContext &parent_decl_ctx) override {
     return CompilerDeclContext();
   }
 
   void AddSymbols(Symtab &symtab) override;
 
   llvm::Expected<lldb::addr_t> GetParameterStackSize(Symbol &symbol) override;
 
   lldb::UnwindPlanSP

lldb/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.cpp

for (size_t i = 0, size = GetNumCompileUnits(); i < size; ++i) {
     CompileUnit &cu = *GetCompileUnitAtIndex(i);
     cu.ResolveSymbolContext(file_spec, line, check_inlines,
                             /*exact*/ false, resolve_scope, sc_list);
   }
   return sc_list.GetSize() - old_size;
 }
 
 void SymbolFileBreakpad::FindFunctions(
-    ConstString name, const CompilerDeclContext *parent_decl_ctx,
+    ConstString name, const CompilerDeclContext &parent_decl_ctx,
     FunctionNameType name_type_mask, bool include_inlines,
     SymbolContextList &sc_list) {
   // TODO
 }
 
 void SymbolFileBreakpad::FindFunctions(const RegularExpression &regex,
                                        bool include_inlines,
                                        SymbolContextList &sc_list) {
   // TODO
 }
 
 void SymbolFileBreakpad::FindTypes(
-    ConstString name, const CompilerDeclContext *parent_decl_ctx,
+    ConstString name, const CompilerDeclContext &parent_decl_ctx,
     uint32_t max_matches, llvm::DenseSet<SymbolFile *> &searched_symbol_files,
     TypeMap &types) {}
 
 void SymbolFileBreakpad::FindTypes(
     llvm::ArrayRef<CompilerContext> pattern, LanguageSet languages,
     llvm::DenseSet<SymbolFile *> &searched_symbol_files, TypeMap &types) {}
 
 void SymbolFileBreakpad::AddSymbols(Symtab &symtab) {

lldb/source/Plugins/SymbolFile/DWARF/DWARFIndex.cpp

void DWARFIndex::ProcessFunctionDIE(llvm::StringRef name, DIERef ref,
   // we have a context specified (no methods in namespaces).
   uint32_t looking_for_nonmethods =
       name_type_mask & ~(eFunctionNameTypeMethod | eFunctionNameTypeSelector);
   if (!looking_for_nonmethods && parent_decl_ctx.IsValid())
     return;
 
   // Otherwise, we need to also check that the context matches. If it does not
   // match, we do nothing.
-  if (!SymbolFileDWARF::DIEInDeclContext(&parent_decl_ctx, die))
+  if (!SymbolFileDWARF::DIEInDeclContext(parent_decl_ctx, die))
     return;
 
   // In case of a full match, we just insert everything we find.
   if (name_type_mask & eFunctionNameTypeFull) {
     dies.push_back(die);
     return;
   }
 

lldb/source/Plugins/SymbolFile/DWARF/ManualDWARFIndex.cpp

void ManualDWARFIndex::GetFunctions(ConstString name, SymbolFileDWARF &dwarf,
 
   if (name_type_mask & eFunctionNameTypeFull) {
     DIEArray offsets;
     m_set.function_fullnames.Find(name, offsets);
     for (const DIERef &die_ref: offsets) {
       DWARFDIE die = dwarf.GetDIE(die_ref);
       if (!die)
         continue;
-      if (SymbolFileDWARF::DIEInDeclContext(&parent_decl_ctx, die))
+      if (SymbolFileDWARF::DIEInDeclContext(parent_decl_ctx, die))
         dies.push_back(die);
     }
   }
   if (name_type_mask & eFunctionNameTypeBase) {
     DIEArray offsets;
     m_set.function_basenames.Find(name, offsets);
     for (const DIERef &die_ref: offsets) {
       DWARFDIE die = dwarf.GetDIE(die_ref);
       if (!die)
         continue;
-      if (SymbolFileDWARF::DIEInDeclContext(&parent_decl_ctx, die))
+      if (SymbolFileDWARF::DIEInDeclContext(parent_decl_ctx, die))
         dies.push_back(die);
     }
     offsets.clear();
   }
 
   if (name_type_mask & eFunctionNameTypeMethod && !parent_decl_ctx.IsValid()) {
     DIEArray offsets;
     m_set.function_methods.Find(name, offsets);

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

public:
   uint32_t
   ResolveSymbolContext(const lldb_private::FileSpec &file_spec, uint32_t line,
                        bool check_inlines,
                        lldb::SymbolContextItem resolve_scope,
                        lldb_private::SymbolContextList &sc_list) override;
 
   void
   FindGlobalVariables(lldb_private::ConstString name,
-                      const lldb_private::CompilerDeclContext *parent_decl_ctx,
+                      const lldb_private::CompilerDeclContext &parent_decl_ctx,
                       uint32_t max_matches,
                       lldb_private::VariableList &variables) override;
 
   void FindGlobalVariables(const lldb_private::RegularExpression &regex,
                            uint32_t max_matches,
                            lldb_private::VariableList &variables) override;
 
   void FindFunctions(lldb_private::ConstString name,
-                     const lldb_private::CompilerDeclContext *parent_decl_ctx,
+                     const lldb_private::CompilerDeclContext &parent_decl_ctx,
                      lldb::FunctionNameType name_type_mask,
                      bool include_inlines,
                      lldb_private::SymbolContextList &sc_list) override;
 
   void FindFunctions(const lldb_private::RegularExpression &regex,
                      bool include_inlines,
                      lldb_private::SymbolContextList &sc_list) override;
 
   void GetMangledNamesForFunction(
       const std::string &scope_qualified_name,
       std::vector<lldb_private::ConstString> &mangled_names) override;
 
   void
   FindTypes(lldb_private::ConstString name,
-            const lldb_private::CompilerDeclContext *parent_decl_ctx,
+            const lldb_private::CompilerDeclContext &parent_decl_ctx,
             uint32_t max_matches,
             llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
             lldb_private::TypeMap &types) override;
 
   void FindTypes(llvm::ArrayRef<lldb_private::CompilerContext> pattern,
                  lldb_private::LanguageSet languages,
                  llvm::DenseSet<SymbolFile *> &searched_symbol_files,
                  lldb_private::TypeMap &types) override;
 
   void GetTypes(lldb_private::SymbolContextScope *sc_scope,
                 lldb::TypeClass type_mask,
                 lldb_private::TypeList &type_list) override;
 
   llvm::Expected<lldb_private::TypeSystem &>
   GetTypeSystemForLanguage(lldb::LanguageType language) override;
 
   lldb_private::CompilerDeclContext FindNamespace(
       lldb_private::ConstString name,
-      const lldb_private::CompilerDeclContext *parent_decl_ctx) override;
+      const lldb_private::CompilerDeclContext &parent_decl_ctx) override;
 
   void PreloadSymbols() override;
 
   std::recursive_mutex &GetModuleMutex() const override;
 
   // PluginInterface protocol
   lldb_private::ConstString GetPluginName() override;
 
GetDwoSymbolFileForCompileUnit(DWARFUnit &dwarf_cu,
                                  const DWARFDebugInfoEntry &cu_die);
 
   virtual llvm::Optional<uint32_t> GetDwoNum() { return llvm::None; }
 
   /// If this is a DWARF object with a single CU, return its DW_AT_dwo_id.
   llvm::Optional<uint64_t> GetDWOId();
 
   static bool
-  DIEInDeclContext(const lldb_private::CompilerDeclContext *parent_decl_ctx,
+  DIEInDeclContext(const lldb_private::CompilerDeclContext &parent_decl_ctx,
                    const DWARFDIE &die);
 
   std::vector<std::unique_ptr<lldb_private::CallEdge>>
   ParseCallEdgesInFunction(UserID func_id) override;
 
   void Dump(lldb_private::Stream &s) override;
 
   void DumpClangAST(lldb_private::Stream &s) override;
typedef llvm::DenseMap<lldb::opaque_compiler_type_t, lldb::user_id_t>
       ClangTypeToDIE;
 
   DISALLOW_COPY_AND_ASSIGN(SymbolFileDWARF);
 
   virtual void LoadSectionData(lldb::SectionType sect_type,
                                lldb_private::DWARFDataExtractor &data);
 
   bool DeclContextMatchesThisSymbolFile(
-      const lldb_private::CompilerDeclContext *decl_ctx);
+      const lldb_private::CompilerDeclContext &decl_ctx);
 
   uint32_t CalculateNumCompileUnits() override;
 
   lldb::CompUnitSP ParseCompileUnitAtIndex(uint32_t index) override;
 
   lldb_private::TypeList &GetTypeList() override;
 
   lldb::CompUnitSP ParseCompileUnit(DWARFCompileUnit &dwarf_cu);

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

 std::recursive_mutex &SymbolFileDWARF::GetModuleMutex() const {
   lldb::ModuleSP module_sp(m_debug_map_module_wp.lock());
   if (module_sp)
     return module_sp->GetMutex();
   return GetObjectFile()->GetModule()->GetMutex();
 }
 
 bool SymbolFileDWARF::DeclContextMatchesThisSymbolFile(
-    const lldb_private::CompilerDeclContext *decl_ctx) {
-  if (decl_ctx == nullptr || !decl_ctx->IsValid()) {
+    const lldb_private::CompilerDeclContext &decl_ctx) {
+  if (!decl_ctx.IsValid()) {
     // Invalid namespace decl which means we aren't matching only things in
     // this symbol file, so return true to indicate it matches this symbol
     // file.
     return true;
   }
 
-  TypeSystem *decl_ctx_type_system = decl_ctx->GetTypeSystem();
+  TypeSystem *decl_ctx_type_system = decl_ctx.GetTypeSystem();
   auto type_system_or_err = GetTypeSystemForLanguage(
       decl_ctx_type_system->GetMinimumLanguage(nullptr));
   if (auto err = type_system_or_err.takeError()) {
     LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
                    std::move(err),
                    "Unable to match namespace decl using TypeSystem");
     return false;
   }
 
   if (decl_ctx_type_system == &type_system_or_err.get())
     return true; // The type systems match, return true
 
   // The namespace AST was valid, and it does not match...
   Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS));
 
   if (log)
     GetObjectFile()->GetModule()->LogMessage(
         log, "Valid namespace does not match symbol file");
 
   return false;
 }
 
 void SymbolFileDWARF::FindGlobalVariables(
-    ConstString name, const CompilerDeclContext *parent_decl_ctx,
+    ConstString name, const CompilerDeclContext &parent_decl_ctx,
     uint32_t max_matches, VariableList &variables) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS));
 
   if (log)
     GetObjectFile()->GetModule()->LogMessage(
         log,
         "SymbolFileDWARF::FindGlobalVariables (name=\"%s\", "
         "parent_decl_ctx=%p, max_matches=%u, variables)",
-        name.GetCString(), static_cast<const void *>(parent_decl_ctx),
+        name.GetCString(), static_cast<const void *>(&parent_decl_ctx),
         max_matches);
 
   if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
     return;
 
   DWARFDebugInfo *info = DebugInfo();
   if (!info)
     return;
for (size_t i = 0; i < num_die_matches && !done; ++i) {
             continue;
           sc.comp_unit = GetCompUnitForDWARFCompUnit(*dwarf_cu);
 
           if (parent_decl_ctx) {
             if (DWARFASTParser *dwarf_ast = GetDWARFParser(*die.GetCU())) {
               CompilerDeclContext actual_parent_decl_ctx =
                   dwarf_ast->GetDeclContextContainingUIDFromDWARF(die);
               if (!actual_parent_decl_ctx ||
-                  actual_parent_decl_ctx != *parent_decl_ctx)
+                  actual_parent_decl_ctx != parent_decl_ctx)
                 continue;
             }
           }
 
           ParseVariables(sc, die, LLDB_INVALID_ADDRESS, false, false,
                          &variables);
           while (pruned_idx < variables.GetSize()) {
             VariableSP var_sp = variables.GetVariableAtIndex(pruned_idx);
void SymbolFileDWARF::FindGlobalVariables(
 
   // Return the number of variable that were appended to the list
   const uint32_t num_matches = variables.GetSize() - original_size;
   if (log && num_matches > 0) {
     GetObjectFile()->GetModule()->LogMessage(
         log,
         "SymbolFileDWARF::FindGlobalVariables (name=\"%s\", "
         "parent_decl_ctx=%p, max_matches=%u, variables) => %u",
-        name.GetCString(), static_cast<const void *>(parent_decl_ctx),
+        name.GetCString(), static_cast<const void *>(&parent_decl_ctx),
         max_matches, num_matches);
   }
 }
 
 void SymbolFileDWARF::FindGlobalVariables(const RegularExpression &regex,
                                           uint32_t max_matches,
                                           VariableList &variables) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
if (auto section_sp = addr.GetSection()) {
         return true;
       }
     }
   }
 
   return false;
 }
 
-bool SymbolFileDWARF::DIEInDeclContext(const CompilerDeclContext *decl_ctx,
+bool SymbolFileDWARF::DIEInDeclContext(const CompilerDeclContext &decl_ctx,
                                        const DWARFDIE &die) {
   // If we have no parent decl context to match this DIE matches, and if the
   // parent decl context isn't valid, we aren't trying to look for any
   // particular decl context so any die matches.
-  if (decl_ctx == nullptr || !decl_ctx->IsValid())
+  if (!decl_ctx.IsValid())
     return true;
 
   if (die) {
     if (DWARFASTParser *dwarf_ast = GetDWARFParser(*die.GetCU())) {
       if (CompilerDeclContext actual_decl_ctx =
               dwarf_ast->GetDeclContextContainingUIDFromDWARF(die))
-        return decl_ctx->IsContainedInLookup(actual_decl_ctx);
+        return decl_ctx.IsContainedInLookup(actual_decl_ctx);
     }
   }
   return false;
 }
 
 void SymbolFileDWARF::FindFunctions(ConstString name,
-                                    const CompilerDeclContext *parent_decl_ctx,
+                                    const CompilerDeclContext &parent_decl_ctx,
                                     FunctionNameType name_type_mask,
                                     bool include_inlines,
                                     SymbolContextList &sc_list) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
   Timer scoped_timer(func_cat, "SymbolFileDWARF::FindFunctions (name = '%s')",
                      name.AsCString());
 
void SymbolFileDWARF::FindFunctions(ConstString name,
 
   // Remember how many sc_list are in the list before we search in case we are
   // appending the results to a variable list.
 
   const uint32_t original_size = sc_list.GetSize();
 
   llvm::DenseSet<const DWARFDebugInfoEntry *> resolved_dies;
   DIEArray offsets;
-  CompilerDeclContext empty_decl_ctx;
-  if (!parent_decl_ctx)
-    parent_decl_ctx = &empty_decl_ctx;
 
   std::vector<DWARFDIE> dies;
-  m_index->GetFunctions(name, *this, *parent_decl_ctx, name_type_mask, dies);
+  m_index->GetFunctions(name, *this, parent_decl_ctx, name_type_mask, dies);
   for (const DWARFDIE &die : dies) {
     if (resolved_dies.insert(die.GetDIE()).second)
       ResolveFunction(die, include_inlines, sc_list);
   }
 
   // Return the number of variable that were appended to the list
   const uint32_t num_matches = sc_list.GetSize() - original_size;
 
void SymbolFileDWARF::GetMangledNamesForFunction(
   for (lldb::user_id_t uid :
        m_function_scope_qualified_name_map.lookup(scope_qualified_name)) {
     DWARFDIE die = GetDIE(uid);
     mangled_names.push_back(ConstString(die.GetMangledName()));
   }
 }
 
 void SymbolFileDWARF::FindTypes(
-    ConstString name, const CompilerDeclContext *parent_decl_ctx,
+    ConstString name, const CompilerDeclContext &parent_decl_ctx,
     uint32_t max_matches,
     llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
     TypeMap &types) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   // Make sure we haven't already searched this SymbolFile before.
   if (!searched_symbol_files.insert(this).second)
     return;
 
   DWARFDebugInfo *info = DebugInfo();
   if (!info)
     return;
 
   Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS));
 
   if (log) {
     if (parent_decl_ctx)
       GetObjectFile()->GetModule()->LogMessage(
           log,
           "SymbolFileDWARF::FindTypes (sc, name=\"%s\", parent_decl_ctx = "
           "%p (\"%s\"), max_matches=%u, type_list)",
-          name.GetCString(), static_cast<const void *>(parent_decl_ctx),
-          parent_decl_ctx->GetName().AsCString("<NULL>"), max_matches);
+          name.GetCString(), static_cast<const void *>(&parent_decl_ctx),
+          parent_decl_ctx.GetName().AsCString("<NULL>"), max_matches);
     else
       GetObjectFile()->GetModule()->LogMessage(
           log,
           "SymbolFileDWARF::FindTypes (sc, name=\"%s\", parent_decl_ctx = "
           "NULL, max_matches=%u, type_list)",
           name.GetCString(), max_matches);
   }
 
void SymbolFileDWARF::FindTypes(
   }
 
   if (log && types.GetSize()) {
     if (parent_decl_ctx) {
       GetObjectFile()->GetModule()->LogMessage(
           log,
           "SymbolFileDWARF::FindTypes (sc, name=\"%s\", parent_decl_ctx "
           "= %p (\"%s\"), max_matches=%u, type_list) => %u",
-          name.GetCString(), static_cast<const void *>(parent_decl_ctx),
-          parent_decl_ctx->GetName().AsCString("<NULL>"), max_matches,
+          name.GetCString(), static_cast<const void *>(&parent_decl_ctx),
+          parent_decl_ctx.GetName().AsCString("<NULL>"), max_matches,
           types.GetSize());
     } else {
       GetObjectFile()->GetModule()->LogMessage(
           log,
           "SymbolFileDWARF::FindTypes (sc, name=\"%s\", parent_decl_ctx "
           "= NULL, max_matches=%u, type_list) => %u",
           name.GetCString(), max_matches, types.GetSize());
     }
void SymbolFileDWARF::FindTypes(
   for (const auto &pair : m_external_type_modules)
     if (ModuleSP external_module_sp = pair.second)
       external_module_sp->FindTypes(pattern, languages, searched_symbol_files,
                                     types);
 }
 
 CompilerDeclContext
 SymbolFileDWARF::FindNamespace(ConstString name,
-                               const CompilerDeclContext *parent_decl_ctx) {
+                               const CompilerDeclContext &parent_decl_ctx) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS));
 
   if (log) {
     GetObjectFile()->GetModule()->LogMessage(
         log, "SymbolFileDWARF::FindNamespace (sc, name=\"%s\")",
         name.GetCString());
   }

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.h

uint32_t ResolveSymbolContext(const lldb_private::Address &so_addr,
                                 lldb_private::SymbolContext &sc) override;
   uint32_t
   ResolveSymbolContext(const lldb_private::FileSpec &file_spec, uint32_t line,
                        bool check_inlines,
                        lldb::SymbolContextItem resolve_scope,
                        lldb_private::SymbolContextList &sc_list) override;
   void
   FindGlobalVariables(lldb_private::ConstString name,
-                      const lldb_private::CompilerDeclContext *parent_decl_ctx,
+                      const lldb_private::CompilerDeclContext &parent_decl_ctx,
                       uint32_t max_matches,
                       lldb_private::VariableList &variables) override;
   void FindGlobalVariables(const lldb_private::RegularExpression &regex,
                            uint32_t max_matches,
                            lldb_private::VariableList &variables) override;
   void FindFunctions(lldb_private::ConstString name,
-                     const lldb_private::CompilerDeclContext *parent_decl_ctx,
+                     const lldb_private::CompilerDeclContext &parent_decl_ctx,
                      lldb::FunctionNameType name_type_mask,
                      bool include_inlines,
                      lldb_private::SymbolContextList &sc_list) override;
   void FindFunctions(const lldb_private::RegularExpression &regex,
                      bool include_inlines,
                      lldb_private::SymbolContextList &sc_list) override;
   void
   FindTypes(lldb_private::ConstString name,
-            const lldb_private::CompilerDeclContext *parent_decl_ctx,
+            const lldb_private::CompilerDeclContext &parent_decl_ctx,
             uint32_t max_matches,
             llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
             lldb_private::TypeMap &types) override;
   void
   FindTypes(llvm::ArrayRef<lldb_private::CompilerContext> context,
             lldb_private::LanguageSet languages,
             llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
             lldb_private::TypeMap &types) override;
   lldb_private::CompilerDeclContext FindNamespace(
       lldb_private::ConstString name,
-      const lldb_private::CompilerDeclContext *parent_decl_ctx) override;
+      const lldb_private::CompilerDeclContext &parent_decl_ctx) override;
   void GetTypes(lldb_private::SymbolContextScope *sc_scope,
                 lldb::TypeClass type_mask,
                 lldb_private::TypeList &type_list) override;
   std::vector<std::unique_ptr<lldb_private::CallEdge>>
   ParseCallEdgesInFunction(lldb_private::UserID func_id) override;
 
   void DumpClangAST(lldb_private::Stream &s) override;
 
protected:
   SymbolContainsSymbolWithIndex(uint32_t *symbol_idx_ptr,
                                 const CompileUnitInfo *comp_unit_info);
 
   static int SymbolContainsSymbolWithID(lldb::user_id_t *symbol_idx_ptr,
                                         const CompileUnitInfo *comp_unit_info);
 
   void PrivateFindGlobalVariables(
       lldb_private::ConstString name,
-      const lldb_private::CompilerDeclContext *parent_decl_ctx,
+      const lldb_private::CompilerDeclContext &parent_decl_ctx,
       const std::vector<uint32_t> &name_symbol_indexes, uint32_t max_matches,
       lldb_private::VariableList &variables);
 
   void SetCompileUnit(SymbolFileDWARF *oso_dwarf,
                       const lldb::CompUnitSP &cu_sp);
 
   lldb::CompUnitSP GetCompileUnit(SymbolFileDWARF *oso_dwarf);
 

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp

if (resolve) {
         oso_dwarf->ResolveSymbolContext(file_spec, line, check_inlines,
                                         resolve_scope, sc_list);
     }
   }
   return sc_list.GetSize() - initial;
 }
 
 void SymbolFileDWARFDebugMap::PrivateFindGlobalVariables(
-    ConstString name, const CompilerDeclContext *parent_decl_ctx,
+    ConstString name, const CompilerDeclContext &parent_decl_ctx,
     const std::vector<uint32_t>
         &indexes, // Indexes into the symbol table that match "name"
     uint32_t max_matches, VariableList &variables) {
   const size_t match_count = indexes.size();
   for (size_t i = 0; i < match_count; ++i) {
     uint32_t oso_idx;
     CompileUnitInfo *comp_unit_info =
         GetCompileUnitInfoForSymbolWithIndex(indexes[i], &oso_idx);
     if (comp_unit_info) {
       SymbolFileDWARF *oso_dwarf = GetSymbolFileByOSOIndex(oso_idx);
       if (oso_dwarf) {
         oso_dwarf->FindGlobalVariables(name, parent_decl_ctx, max_matches,
                                        variables);
         if (variables.GetSize() > max_matches)
           break;
       }
     }
   }
 }
 
 void SymbolFileDWARFDebugMap::FindGlobalVariables(
-    ConstString name, const CompilerDeclContext *parent_decl_ctx,
+    ConstString name, const CompilerDeclContext &parent_decl_ctx,
     uint32_t max_matches, VariableList &variables) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   uint32_t total_matches = 0;
 
   ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool {
     const uint32_t old_size = variables.GetSize();
     oso_dwarf->FindGlobalVariables(name, parent_decl_ctx, max_matches,
                                    variables);
if (sc.function) {
         continue;
       }
     }
     ++i;
   }
 }
 
 void SymbolFileDWARFDebugMap::FindFunctions(
-    ConstString name, const CompilerDeclContext *parent_decl_ctx,
+    ConstString name, const CompilerDeclContext &parent_decl_ctx,
     FunctionNameType name_type_mask, bool include_inlines,
     SymbolContextList &sc_list) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
   Timer scoped_timer(func_cat,
                      "SymbolFileDWARFDebugMap::FindFunctions (name = %s)",
                      name.GetCString());
 
if (!must_be_implementation) {
     });
 
     return type_sp;
   }
   return TypeSP();
 }
 
 void SymbolFileDWARFDebugMap::FindTypes(
-    ConstString name, const CompilerDeclContext *parent_decl_ctx,
+    ConstString name, const CompilerDeclContext &parent_decl_ctx,
     uint32_t max_matches,
     llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
     TypeMap &types) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool {
     oso_dwarf->FindTypes(name, parent_decl_ctx, max_matches,
                          searched_symbol_files, types);
     return types.GetSize() >= max_matches;

 //  if (oso_dwarf)
 //      return oso_dwarf->FindTypes (sc, regex, append, max_matches, encoding,
 //      udt_uid, types);
 //  return 0;
 //}
 
 CompilerDeclContext SymbolFileDWARFDebugMap::FindNamespace(
     lldb_private::ConstString name,
-    const CompilerDeclContext *parent_decl_ctx) {
+    const CompilerDeclContext &parent_decl_ctx) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   CompilerDeclContext matching_namespace;
 
   ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool {
     matching_namespace = oso_dwarf->FindNamespace(name, parent_decl_ctx);
 
     return (bool)matching_namespace;
   });

lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.h

public:
 
   bool ParseImportedModules(
       const SymbolContext &sc,
       std::vector<lldb_private::SourceModule> &imported_modules) override;
 
   size_t ParseBlocksRecursive(Function &func) override;
 
   void FindGlobalVariables(ConstString name,
-                           const CompilerDeclContext *parent_decl_ctx,
+                           const CompilerDeclContext &parent_decl_ctx,
                            uint32_t max_matches,
                            VariableList &variables) override;
 
   size_t ParseVariablesForContext(const SymbolContext &sc) override;
 
   void AddSymbols(Symtab &symtab) override;
 
   CompilerDecl GetDeclForUID(lldb::user_id_t uid) override;
uint32_t ResolveSymbolContext(const FileSpec &file_spec, uint32_t line,
                                 bool check_inlines,
                                 lldb::SymbolContextItem resolve_scope,
                                 SymbolContextList &sc_list) override;
 
   void GetTypes(SymbolContextScope *sc_scope, lldb::TypeClass type_mask,
                 TypeList &type_list) override;
 
   void FindFunctions(ConstString name,
-                     const CompilerDeclContext *parent_decl_ctx,
+                     const CompilerDeclContext &parent_decl_ctx,
                      lldb::FunctionNameType name_type_mask,
                      bool include_inlines, SymbolContextList &sc_list) override;
 
   void FindFunctions(const RegularExpression &regex, bool include_inlines,
                      SymbolContextList &sc_list) override;
 
-  void FindTypes(ConstString name, const CompilerDeclContext *parent_decl_ctx,
+  void FindTypes(ConstString name, const CompilerDeclContext &parent_decl_ctx,
                  uint32_t max_matches,
                  llvm::DenseSet<SymbolFile *> &searched_symbol_files,
                  TypeMap &types) override;
 
   void FindTypes(llvm::ArrayRef<CompilerContext> pattern, LanguageSet languages,
                  llvm::DenseSet<SymbolFile *> &searched_symbol_files,
                  TypeMap &types) override;
 
   llvm::Expected<TypeSystem &>
   GetTypeSystemForLanguage(lldb::LanguageType language) override;
 
   CompilerDeclContext
   FindNamespace(ConstString name,
-                const CompilerDeclContext *parent_decl_ctx) override;
+                const CompilerDeclContext &parent_decl_ctx) override;
 
   ConstString GetPluginName() override;
 
   uint32_t GetPluginVersion() override;
 
   llvm::pdb::PDBFile &GetPDBFile() { return m_index->pdb(); }
   const llvm::pdb::PDBFile &GetPDBFile() const { return m_index->pdb(); }
 

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

size_t SymbolFileNativePDB::ParseBlocksRecursive(Function &func) {
   GetOrCreateBlock(PdbSymUid(func.GetID()).asCompilandSym());
   // FIXME: Parse child blocks
   return 1;
 }
 
 void SymbolFileNativePDB::DumpClangAST(Stream &s) { m_ast->Dump(s); }
 
 void SymbolFileNativePDB::FindGlobalVariables(
-    ConstString name, const CompilerDeclContext *parent_decl_ctx,
+    ConstString name, const CompilerDeclContext &parent_decl_ctx,
     uint32_t max_matches, VariableList &variables) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   using SymbolAndOffset = std::pair<uint32_t, llvm::codeview::CVSymbol>;
 
   std::vector<SymbolAndOffset> results = m_index->globals().findRecordsByName(
       name.GetStringRef(), m_index->symrecords());
   for (const SymbolAndOffset &result : results) {
     VariableSP var;
for (const SymbolAndOffset &result : results) {
     }
     default:
       continue;
     }
   }
 }
 
 void SymbolFileNativePDB::FindFunctions(
-    ConstString name, const CompilerDeclContext *parent_decl_ctx,
+    ConstString name, const CompilerDeclContext &parent_decl_ctx,
     FunctionNameType name_type_mask, bool include_inlines,
     SymbolContextList &sc_list) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   // For now we only support lookup by method name.
   if (!(name_type_mask & eFunctionNameTypeMethod))
     return;
 
   using SymbolAndOffset = std::pair<uint32_t, llvm::codeview::CVSymbol>;
void SymbolFileNativePDB::FindFunctions(
   }
 }
 
 void SymbolFileNativePDB::FindFunctions(const RegularExpression &regex,
                                         bool include_inlines,
                                         SymbolContextList &sc_list) {}
 
 void SymbolFileNativePDB::FindTypes(
-    ConstString name, const CompilerDeclContext *parent_decl_ctx,
+    ConstString name, const CompilerDeclContext &parent_decl_ctx,
     uint32_t max_matches, llvm::DenseSet<SymbolFile *> &searched_symbol_files,
     TypeMap &types) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   if (!name)
     return;
 
   searched_symbol_files.clear();
   searched_symbol_files.insert(this);

 }
 
 void SymbolFileNativePDB::GetTypes(lldb_private::SymbolContextScope *sc_scope,
                                    TypeClass type_mask,
                                    lldb_private::TypeList &type_list) {}
 
 CompilerDeclContext
 SymbolFileNativePDB::FindNamespace(ConstString name,
-                                   const CompilerDeclContext *parent_decl_ctx) {
+                                   const CompilerDeclContext &parent_decl_ctx) {
   return {};
 }
 
 llvm::Expected<TypeSystem &>
 SymbolFileNativePDB::GetTypeSystemForLanguage(lldb::LanguageType language) {
   auto type_system_or_err =
       m_objfile_sp->GetModule()->GetTypeSystemForLanguage(language);
   if (type_system_or_err) {

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

public:
   uint32_t
   ResolveSymbolContext(const lldb_private::FileSpec &file_spec, uint32_t line,
                        bool check_inlines,
                        lldb::SymbolContextItem resolve_scope,
                        lldb_private::SymbolContextList &sc_list) override;
 
   void
   FindGlobalVariables(lldb_private::ConstString name,
-                      const lldb_private::CompilerDeclContext *parent_decl_ctx,
+                      const lldb_private::CompilerDeclContext &parent_decl_ctx,
                       uint32_t max_matches,
                       lldb_private::VariableList &variables) override;
 
   void FindGlobalVariables(const lldb_private::RegularExpression &regex,
                            uint32_t max_matches,
                            lldb_private::VariableList &variables) override;
 
   void FindFunctions(lldb_private::ConstString name,
-                     const lldb_private::CompilerDeclContext *parent_decl_ctx,
+                     const lldb_private::CompilerDeclContext &parent_decl_ctx,
                      lldb::FunctionNameType name_type_mask,
                      bool include_inlines,
                      lldb_private::SymbolContextList &sc_list) override;
 
   void FindFunctions(const lldb_private::RegularExpression &regex,
                      bool include_inlines,
                      lldb_private::SymbolContextList &sc_list) override;
 
   void GetMangledNamesForFunction(
       const std::string &scope_qualified_name,
       std::vector<lldb_private::ConstString> &mangled_names) override;
 
   void AddSymbols(lldb_private::Symtab &symtab) override;
 
   void
   FindTypes(lldb_private::ConstString name,
-            const lldb_private::CompilerDeclContext *parent_decl_ctx,
+            const lldb_private::CompilerDeclContext &parent_decl_ctx,
             uint32_t max_matches,
             llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
             lldb_private::TypeMap &types) override;
 
   void FindTypes(llvm::ArrayRef<lldb_private::CompilerContext> pattern,
                  lldb_private::LanguageSet languages,
                  llvm::DenseSet<SymbolFile *> &searched_symbol_files,
                  lldb_private::TypeMap &types) override;
 
   void FindTypesByRegex(const lldb_private::RegularExpression &regex,
                         uint32_t max_matches, lldb_private::TypeMap &types);
 
   void GetTypes(lldb_private::SymbolContextScope *sc_scope,
                 lldb::TypeClass type_mask,
                 lldb_private::TypeList &type_list) override;
 
   llvm::Expected<lldb_private::TypeSystem &>
   GetTypeSystemForLanguage(lldb::LanguageType language) override;
 
   lldb_private::CompilerDeclContext FindNamespace(
       lldb_private::ConstString name,
-      const lldb_private::CompilerDeclContext *parent_decl_ctx) override;
+      const lldb_private::CompilerDeclContext &parent_decl_ctx) override;
 
   lldb_private::ConstString GetPluginName() override;
 
   uint32_t GetPluginVersion() override;
 
   llvm::pdb::IPDBSession &GetPDBSession();
 
   const llvm::pdb::IPDBSession &GetPDBSession() const;
private:
   bool ParseCompileUnitLineTable(lldb_private::CompileUnit &comp_unit,
                                  uint32_t match_line);
 
   void BuildSupportFileIdToSupportFileIndexMap(
       const llvm::pdb::PDBSymbolCompiland &pdb_compiland,
       llvm::DenseMap<uint32_t, uint32_t> &index_map) const;
 
   void FindTypesByName(llvm::StringRef name,
-                       const lldb_private::CompilerDeclContext *parent_decl_ctx,
+                       const lldb_private::CompilerDeclContext &parent_decl_ctx,
                        uint32_t max_matches, lldb_private::TypeMap &types);
 
   std::string GetMangledForPDBData(const llvm::pdb::PDBSymbolData &pdb_data);
 
   lldb::VariableSP
   ParseVariableForPDBData(const lldb_private::SymbolContext &sc,
                           const llvm::pdb::PDBSymbolData &pdb_data);
 
bool ResolveFunction(const llvm::pdb::PDBSymbolFunc &pdb_func,
                        lldb_private::SymbolContextList &sc_list);
 
   bool ResolveFunction(uint32_t uid, bool include_inlines,
                        lldb_private::SymbolContextList &sc_list);
 
   void CacheFunctionNames();
 
   bool DeclContextMatchesThisSymbolFile(
-      const lldb_private::CompilerDeclContext *decl_ctx);
+      const lldb_private::CompilerDeclContext &decl_ctx);
 
   uint32_t GetCompilandId(const llvm::pdb::PDBSymbolData &data);
 
   llvm::DenseMap<uint32_t, lldb::CompUnitSP> m_comp_units;
   llvm::DenseMap<uint32_t, lldb::TypeSP> m_types;
   llvm::DenseMap<uint32_t, lldb::VariableSP> m_variables;
   llvm::DenseMap<uint64_t, std::string> m_public_names;
 

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

if (auto results = pdb_symbol.findAllChildren()) {
     while (auto result = results->getNext())
       num_added += ParseVariables(sc, *result, variable_list);
   }
 
   return num_added;
 }
 
 void SymbolFilePDB::FindGlobalVariables(
-    lldb_private::ConstString name,
-    const lldb_private::CompilerDeclContext *parent_decl_ctx,
+    lldb_private::ConstString name, const CompilerDeclContext &parent_decl_ctx,
     uint32_t max_matches, lldb_private::VariableList &variables) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
     return;
   if (name.IsEmpty())
     return;
 
   auto results = m_global_scope_up->findAllChildren<PDBSymbolData>();
if (!name.GetStringRef().equals(
             MSVCUndecoratedNameParser::DropScope(pdb_data->getName())))
       continue;
 
     sc.comp_unit = ParseCompileUnitForUID(GetCompilandId(*pdb_data)).get();
     // FIXME: We are not able to determine the compile unit.
     if (sc.comp_unit == nullptr)
       continue;
 
-    if (parent_decl_ctx && GetDeclContextContainingUID(
-                               result->getSymIndexId()) != *parent_decl_ctx)
+    if (GetDeclContextContainingUID(result->getSymIndexId()) != parent_decl_ctx)
       continue;
 
     ParseVariables(sc, *pdb_data, &variables);
     matches = variables.GetSize() - old_size;
   }
 }
 
 void SymbolFilePDB::FindGlobalVariables(
void SymbolFilePDB::CacheFunctionNames() {
   m_func_method_names.Sort();
   m_func_method_names.SizeToFit();
   m_func_base_names.Sort();
   m_func_base_names.SizeToFit();
 }
 
 void SymbolFilePDB::FindFunctions(
     lldb_private::ConstString name,
-    const lldb_private::CompilerDeclContext *parent_decl_ctx,
+    const lldb_private::CompilerDeclContext &parent_decl_ctx,
     FunctionNameType name_type_mask, bool include_inlines,
     lldb_private::SymbolContextList &sc_list) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   lldbassert((name_type_mask & eFunctionNameTypeAuto) == 0);
 
   if (name_type_mask == eFunctionNameTypeNone)
     return;
   if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
auto ResolveFn = [this, &name, parent_decl_ctx, include_inlines, &sc_list,
       std::vector<uint32_t> ids;
       if (!Names.GetValues(name, ids))
         return;
 
       for (uint32_t id : ids) {
         if (resolved_ids.find(id) != resolved_ids.end())
           continue;
 
-        if (parent_decl_ctx &&
-            GetDeclContextContainingUID(id) != *parent_decl_ctx)
+        if (GetDeclContextContainingUID(id) != parent_decl_ctx)
           continue;
 
         if (ResolveFunction(id, include_inlines, sc_list))
           resolved_ids.insert(id);
       }
     };
     if (name_type_mask & eFunctionNameTypeFull) {
       ResolveFn(m_func_full_names);
symtab.AddSymbol(
                ));
   }
 
   symtab.CalculateSymbolSizes();
   symtab.Finalize();
 }
 
 void SymbolFilePDB::FindTypes(
-    lldb_private::ConstString name,
-    const lldb_private::CompilerDeclContext *parent_decl_ctx,
+    lldb_private::ConstString name, const CompilerDeclContext &parent_decl_ctx,
     uint32_t max_matches,
     llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
     lldb_private::TypeMap &types) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   if (!name)
     return;
   if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
     return;
while (auto result = results->getNext()) {
       types.Insert(iter->second);
       ++matches;
     }
   }
 }
 
 void SymbolFilePDB::FindTypesByName(
     llvm::StringRef name,
-    const lldb_private::CompilerDeclContext *parent_decl_ctx,
+    const lldb_private::CompilerDeclContext &parent_decl_ctx,
     uint32_t max_matches, lldb_private::TypeMap &types) {
   std::unique_ptr<IPDBEnumSymbols> results;
   if (name.empty())
     return;
   results = m_global_scope_up->findAllChildren(PDB_SymType::None);
   if (!results)
     return;
 
default:
       continue;
     }
 
     // This should cause the type to get cached and stored in the `m_types`
     // lookup.
     if (!ResolveTypeUID(result->getSymIndexId()))
       continue;
 
-    if (parent_decl_ctx && GetDeclContextContainingUID(
-                               result->getSymIndexId()) != *parent_decl_ctx)
+    if (GetDeclContextContainingUID(result->getSymIndexId()) != parent_decl_ctx)
       continue;
 
     auto iter = m_types.find(result->getSymIndexId());
     if (iter == m_types.end())
       continue;
     types.Insert(iter->second);
     ++matches;
   }
PDBASTParser *SymbolFilePDB::GetPDBAstParser() {
   auto *clang_type_system =
       llvm::dyn_cast_or_null<TypeSystemClang>(&type_system_or_err.get());
   if (!clang_type_system)
     return nullptr;
 
   return clang_type_system->GetPDBParser();
 }
 
-
-lldb_private::CompilerDeclContext SymbolFilePDB::FindNamespace(
-    lldb_private::ConstString name,
-    const lldb_private::CompilerDeclContext *parent_decl_ctx) {
+lldb_private::CompilerDeclContext
+SymbolFilePDB::FindNamespace(lldb_private::ConstString name,
+                             const CompilerDeclContext &parent_decl_ctx) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   auto type_system_or_err =
       GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
   if (auto err = type_system_or_err.takeError()) {
     LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
                    std::move(err), "Unable to find namespace {}",
                    name.AsCString());
     return CompilerDeclContext();
   }
 
   auto *clang_type_system =
       llvm::dyn_cast_or_null<TypeSystemClang>(&type_system_or_err.get());
   if (!clang_type_system)
     return CompilerDeclContext();
 
   PDBASTParser *pdb = clang_type_system->GetPDBParser();
   if (!pdb)
     return CompilerDeclContext();
 
   clang::DeclContext *decl_context = nullptr;
   if (parent_decl_ctx)
     decl_context = static_cast<clang::DeclContext *>(
-        parent_decl_ctx->GetOpaqueDeclContext());
+        parent_decl_ctx.GetOpaqueDeclContext());
 
   auto namespace_decl =
       pdb->FindNamespaceDecl(decl_context, name.GetStringRef());
   if (!namespace_decl)
     return CompilerDeclContext();
 
   return clang_type_system->CreateDeclContext(namespace_decl);
 }
if (!func_decorated_name.empty()) {
     mangled.SetDemangledName(ConstString(func_undecorated_name));
   } else if (!func_name.empty())
     mangled.SetValue(ConstString(func_name), false);
 
   return mangled;
 }
 
 bool SymbolFilePDB::DeclContextMatchesThisSymbolFile(
-    const lldb_private::CompilerDeclContext *decl_ctx) {
-  if (decl_ctx == nullptr || !decl_ctx->IsValid())
+    const lldb_private::CompilerDeclContext &decl_ctx) {
+  if (!decl_ctx.IsValid())
     return true;
 
-  TypeSystem *decl_ctx_type_system = decl_ctx->GetTypeSystem();
+  TypeSystem *decl_ctx_type_system = decl_ctx.GetTypeSystem();
   if (!decl_ctx_type_system)
     return false;
   auto type_system_or_err = GetTypeSystemForLanguage(
       decl_ctx_type_system->GetMinimumLanguage(nullptr));
   if (auto err = type_system_or_err.takeError()) {
     LLDB_LOG_ERROR(
         lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
         std::move(err),

lldb/source/Symbol/SymbolFile.cpp

 uint32_t SymbolFile::ResolveSymbolContext(const FileSpec &file_spec,
                                           uint32_t line, bool check_inlines,
                                           lldb::SymbolContextItem resolve_scope,
                                           SymbolContextList &sc_list) {
   return 0;
 }
 
 void SymbolFile::FindGlobalVariables(ConstString name,
-                                     const CompilerDeclContext *parent_decl_ctx,
+                                     const CompilerDeclContext &parent_decl_ctx,
                                      uint32_t max_matches,
                                      VariableList &variables) {}
 
 void SymbolFile::FindGlobalVariables(const RegularExpression &regex,
                                      uint32_t max_matches,
                                      VariableList &variables) {}
 
 void SymbolFile::FindFunctions(ConstString name,
-                               const CompilerDeclContext *parent_decl_ctx,
+                               const CompilerDeclContext &parent_decl_ctx,
                                lldb::FunctionNameType name_type_mask,
                                bool include_inlines,
                                SymbolContextList &sc_list) {}
 
 void SymbolFile::FindFunctions(const RegularExpression &regex,
                                bool include_inlines,
                                SymbolContextList &sc_list) {}
 
 void SymbolFile::GetMangledNamesForFunction(
     const std::string &scope_qualified_name,
     std::vector<ConstString> &mangled_names) {
   return;
 }
 
 void SymbolFile::FindTypes(
-    ConstString name, const CompilerDeclContext *parent_decl_ctx,
+    ConstString name, const CompilerDeclContext &parent_decl_ctx,
     uint32_t max_matches,
     llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
     TypeMap &types) {}
 
 void SymbolFile::FindTypes(llvm::ArrayRef<CompilerContext> pattern,
                            LanguageSet languages,
                            llvm::DenseSet<SymbolFile *> &searched_symbol_files,
                            TypeMap &types) {}

lldb/tools/lldb-test/lldb-test.cpp

int opts::breakpoint::evaluateBreakpoints(Debugger &Dbg) {
   return HadErrors;
 }
 
 Expected<CompilerDeclContext>
 opts::symbols::getDeclContext(SymbolFile &Symfile) {
   if (Context.empty())
     return CompilerDeclContext();
   VariableList List;
-  Symfile.FindGlobalVariables(ConstString(Context), nullptr, UINT32_MAX, List);
+  Symfile.FindGlobalVariables(ConstString(Context), CompilerDeclContext(),
+                              UINT32_MAX, List);
   if (List.Empty())
     return make_string_error("Context search didn't find a match.");
   if (List.GetSize() > 1)
     return make_string_error("Context search found multiple matches.");
   return List.GetVariableAtIndex(0)->GetDeclContext();
 }
 
 Error opts::symbols::findFunctions(lldb_private::Module &Module) {
if (!File.empty()) {
     RegularExpression RE(Name);
     assert(RE.IsValid());
     List.Clear();
     Symfile.FindFunctions(RE, true, List);
   } else {
     Expected<CompilerDeclContext> ContextOr = getDeclContext(Symfile);
     if (!ContextOr)
       return ContextOr.takeError();
-    CompilerDeclContext *ContextPtr =
-        ContextOr->IsValid() ? &*ContextOr : nullptr;
+    const CompilerDeclContext &ContextPtr =
+        ContextOr->IsValid() ? *ContextOr : CompilerDeclContext();
 
     List.Clear();
     Symfile.FindFunctions(ConstString(Name), ContextPtr, getFunctionNameFlags(),
                          true, List);
   }
   outs() << formatv("Found {0} functions:\n", List.GetSize());
   StreamString Stream;
   List.Dump(&Stream, nullptr);
Error opts::symbols::findBlocks(lldb_private::Module &Module) {
   return Error::success();
 }
 
 Error opts::symbols::findNamespaces(lldb_private::Module &Module) {
   SymbolFile &Symfile = *Module.GetSymbolFile();
   Expected<CompilerDeclContext> ContextOr = getDeclContext(Symfile);
   if (!ContextOr)
     return ContextOr.takeError();
-  CompilerDeclContext *ContextPtr =
-      ContextOr->IsValid() ? &*ContextOr : nullptr;
+  const CompilerDeclContext &ContextPtr =
+      ContextOr->IsValid() ? *ContextOr : CompilerDeclContext();
 
   CompilerDeclContext Result =
       Symfile.FindNamespace(ConstString(Name), ContextPtr);
   if (Result)
     outs() << "Found namespace: "
            << Result.GetScopeQualifiedName().GetStringRef() << "\n";
   else
     outs() << "Namespace not found.\n";
   return Error::success();
 }
 
 Error opts::symbols::findTypes(lldb_private::Module &Module) {
   SymbolFile &Symfile = *Module.GetSymbolFile();
   Expected<CompilerDeclContext> ContextOr = getDeclContext(Symfile);
   if (!ContextOr)
     return ContextOr.takeError();
-  CompilerDeclContext *ContextPtr =
-      ContextOr->IsValid() ? &*ContextOr : nullptr;
+  const CompilerDeclContext &ContextPtr =
+      ContextOr->IsValid() ? *ContextOr : CompilerDeclContext();
 
   LanguageSet languages;
   if (!Language.empty())
     languages.Insert(Language::GetLanguageTypeFromString(Language));
   
   DenseSet<SymbolFile *> SearchedFiles;
   TypeMap Map;
   if (!Name.empty())
if (Regex) {
     if (!CU)
       return make_string_error("Compile unit `{0}` not found.", File);
 
     List.AddVariables(CU->GetVariableList(true).get());
   } else {
     Expected<CompilerDeclContext> ContextOr = getDeclContext(Symfile);
     if (!ContextOr)
       return ContextOr.takeError();
-    CompilerDeclContext *ContextPtr =
-        ContextOr->IsValid() ? &*ContextOr : nullptr;
+    const CompilerDeclContext &ContextPtr =
+        ContextOr->IsValid() ? *ContextOr : CompilerDeclContext();
 
     Symfile.FindGlobalVariables(ConstString(Name), ContextPtr, UINT32_MAX, List);
   }
   outs() << formatv("Found {0} variables:\n", List.GetSize());
   StreamString Stream;
   List.Dump(&Stream, false);
   outs() << Stream.GetData() << "\n";
   return Error::success();