[SymbolFile] Remove the SymbolContext parameter from FindNamespace

[zturner]

Summary

Every callsite was passing an empty SymbolContext, so this parameter had no effect. Inside the DWARF implementation of this function, however, there was one codepath that checked members of the SymbolContext. Since no call-sites actually ever used this functionality, it was essentially dead code, so I've deleted this code path as well.

lldb/include/lldb/Symbol/SymbolFile.h

virtual size_t GetTypes(lldb_private::SymbolContextScope *sc_scope,
                           lldb_private::TypeList &type_list) = 0;
 
   virtual void PreloadSymbols();
 
   virtual lldb_private::TypeSystem *
   GetTypeSystemForLanguage(lldb::LanguageType language);
 
   virtual CompilerDeclContext
-  FindNamespace(const SymbolContext &sc, const ConstString &name,
+  FindNamespace(const ConstString &name,
                 const CompilerDeclContext *parent_decl_ctx) {
     return CompilerDeclContext();
   }
 
   ObjectFile *GetObjectFile() { return m_obj_file; }
   const ObjectFile *GetObjectFile() const { return m_obj_file; }
 
   virtual std::vector<CallEdge> ParseCallEdgesInFunction(UserID func_id) {

lldb/include/lldb/Symbol/SymbolVendor.h

FindTypes(const SymbolContext &sc, const ConstString &name,
             size_t max_matches,
             llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
             TypeMap &types);
 
   virtual size_t FindTypes(const std::vector<CompilerContext> &context,
                            bool append, TypeMap &types);
 
   virtual CompilerDeclContext
-  FindNamespace(const SymbolContext &sc, const ConstString &name,
+  FindNamespace(const ConstString &name,
                 const CompilerDeclContext *parent_decl_ctx);
 
   virtual size_t GetNumCompileUnits();
 
   virtual bool SetCompileUnitAtIndex(size_t cu_idx,
                                      const lldb::CompUnitSP &cu_sp);
 
   virtual lldb::CompUnitSP GetCompileUnitAtIndex(size_t idx);

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

if (IgnoreName(name, true))
     return;
 
   if (module_sp && namespace_decl) {
     CompilerDeclContext found_namespace_decl;
 
     SymbolVendor *symbol_vendor = module_sp->GetSymbolVendor();
 
     if (symbol_vendor) {
-      SymbolContext null_sc;
-
       found_namespace_decl =
-          symbol_vendor->FindNamespace(null_sc, name, &namespace_decl);
+          symbol_vendor->FindNamespace(name, &namespace_decl);
 
       if (found_namespace_decl) {
         context.m_namespace_map->push_back(
             std::pair<lldb::ModuleSP, CompilerDeclContext>(
                 module_sp, found_namespace_decl));
 
         if (log)
           log->Printf("  CAS::FEVD[%u] Found namespace %s in module %s",
for (size_t i = 0, e = target_images.GetSize(); i < e; ++i) {
 
       CompilerDeclContext found_namespace_decl;
 
       SymbolVendor *symbol_vendor = image->GetSymbolVendor();
 
       if (!symbol_vendor)
         continue;
 
-      SymbolContext null_sc;
-
       found_namespace_decl =
-          symbol_vendor->FindNamespace(null_sc, name, &namespace_decl);
+          symbol_vendor->FindNamespace(name, &namespace_decl);
 
       if (found_namespace_decl) {
         context.m_namespace_map->push_back(
             std::pair<lldb::ModuleSP, CompilerDeclContext>(
                 image, found_namespace_decl));
 
         if (log)
           log->Printf("  CAS::FEVD[%u] Found namespace %s in module %s",
for (ClangASTImporter::NamespaceMap::iterator i = parent_map->begin(),
       lldb::ModuleSP module_sp = i->first;
       CompilerDeclContext module_parent_namespace_decl = i->second;
 
       SymbolVendor *symbol_vendor = module_sp->GetSymbolVendor();
 
       if (!symbol_vendor)
         continue;
 
-      SymbolContext null_sc;
-
-      found_namespace_decl = symbol_vendor->FindNamespace(
-          null_sc, name, &module_parent_namespace_decl);
+      found_namespace_decl =
+          symbol_vendor->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));
 
       if (log)
for (size_t i = 0, e = target_images.GetSize(); i < e; ++i) {
 
       CompilerDeclContext found_namespace_decl;
 
       SymbolVendor *symbol_vendor = image->GetSymbolVendor();
 
       if (!symbol_vendor)
         continue;
 
-      SymbolContext null_sc;
-
       found_namespace_decl =
-          symbol_vendor->FindNamespace(null_sc, name, &null_namespace_decl);
+          symbol_vendor->FindNamespace(name, &null_namespace_decl);
 
       if (!found_namespace_decl)
         continue;
 
       namespace_map->push_back(std::pair<lldb::ModuleSP, CompilerDeclContext>(
           image, found_namespace_decl));
 
       if (log)

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

public:
   size_t FindTypes(const std::vector<CompilerContext> &context, bool append,
                    TypeMap &types) override;
 
   TypeSystem *GetTypeSystemForLanguage(lldb::LanguageType language) override {
     return nullptr;
   }
 
   CompilerDeclContext
-  FindNamespace(const SymbolContext &sc, const ConstString &name,
+  FindNamespace(const ConstString &name,
                 const CompilerDeclContext *parent_decl_ctx) override {
     return CompilerDeclContext();
   }
 
   void AddSymbols(Symtab &symtab) override;
 
   ConstString GetPluginName() override { return GetPluginNameStatic(); }
   uint32_t GetPluginVersion() override { return 1; }
 
 private:
 };
 
 } // namespace breakpad
 } // namespace lldb_private
 
 #endif

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

public:
   size_t GetTypes(lldb_private::SymbolContextScope *sc_scope,
                   lldb::TypeClass type_mask,
                   lldb_private::TypeList &type_list) override;
 
   lldb_private::TypeSystem *
   GetTypeSystemForLanguage(lldb::LanguageType language) override;
 
   lldb_private::CompilerDeclContext FindNamespace(
-      const lldb_private::SymbolContext &sc,
       const lldb_private::ConstString &name,
       const lldb_private::CompilerDeclContext *parent_decl_ctx) override;
 
   void PreloadSymbols() override;
 
   std::recursive_mutex &GetModuleMutex() const override;
 
   //------------------------------------------------------------------

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

for (size_t i = 0; i < num_die_matches; ++i) {
       }
     }
     return num_matches;
   }
   return 0;
 }
 
 CompilerDeclContext
-SymbolFileDWARF::FindNamespace(const SymbolContext &sc, const ConstString &name,
+SymbolFileDWARF::FindNamespace(const ConstString &name,
                                const CompilerDeclContext *parent_decl_ctx) {
   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

public:
   uint32_t
   FindTypes(const lldb_private::SymbolContext &sc,
             const lldb_private::ConstString &name,
             const lldb_private::CompilerDeclContext *parent_decl_ctx,
             bool append, uint32_t max_matches,
             llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
             lldb_private::TypeMap &types) override;
   lldb_private::CompilerDeclContext FindNamespace(
-      const lldb_private::SymbolContext &sc,
       const lldb_private::ConstString &name,
       const lldb_private::CompilerDeclContext *parent_decl_ctx) override;
   size_t GetTypes(lldb_private::SymbolContextScope *sc_scope,
                   lldb::TypeClass type_mask,
                   lldb_private::TypeList &type_list) override;
   std::vector<lldb_private::CallEdge>
   ParseCallEdgesInFunction(lldb_private::UserID func_id) override;
 

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

 //  SymbolFileDWARF *oso_dwarf = GetSymbolFile (sc);
 //  if (oso_dwarf)
 //      return oso_dwarf->FindTypes (sc, regex, append, max_matches, encoding,
 //      udt_uid, types);
 //  return 0;
 //}
 
 CompilerDeclContext SymbolFileDWARFDebugMap::FindNamespace(
-    const lldb_private::SymbolContext &sc,
     const lldb_private::ConstString &name,
     const CompilerDeclContext *parent_decl_ctx) {
   CompilerDeclContext matching_namespace;
-  SymbolFileDWARF *oso_dwarf;
 
-  if (sc.comp_unit) {
-    oso_dwarf = GetSymbolFile(sc);
-    if (oso_dwarf)
-      matching_namespace = oso_dwarf->FindNamespace(sc, name, parent_decl_ctx);
-  } else {
-    ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool {
-      matching_namespace = oso_dwarf->FindNamespace(sc, name, parent_decl_ctx);
+    matching_namespace = oso_dwarf->FindNamespace(name, parent_decl_ctx);
 
-      return (bool)matching_namespace;
-    });
-  }
 
   return matching_namespace;
 }
 
 void SymbolFileDWARFDebugMap::DumpClangAST(Stream &s) {
   ForEachSymbolFile([&s](SymbolFileDWARF *oso_dwarf) -> bool {
     oso_dwarf->DumpClangAST(s);
     return true;

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

uint32_t FindTypes(const SymbolContext &sc, const ConstString &name,
                      TypeMap &types) override;
 
   size_t FindTypes(const std::vector<CompilerContext> &context, bool append,
                    TypeMap &types) override;
 
   TypeSystem *GetTypeSystemForLanguage(lldb::LanguageType language) override;
 
   CompilerDeclContext
-  FindNamespace(const SymbolContext &sc, const ConstString &name,
+  FindNamespace(const ConstString &name,
                 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::GetTypes(lldb_private::SymbolContextScope *sc_scope,
                                      TypeClass type_mask,
                                      lldb_private::TypeList &type_list) {
   return 0;
 }
 
 CompilerDeclContext
-SymbolFileNativePDB::FindNamespace(const SymbolContext &sc,
-                                   const ConstString &name,
+SymbolFileNativePDB::FindNamespace(const ConstString &name,
                                    const CompilerDeclContext *parent_decl_ctx) {
   return {};
 }
 
 TypeSystem *
 SymbolFileNativePDB::GetTypeSystemForLanguage(lldb::LanguageType language) {
   auto type_system =
       m_obj_file->GetModule()->GetTypeSystemForLanguage(language);

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

public:
   size_t GetTypes(lldb_private::SymbolContextScope *sc_scope,
                   lldb::TypeClass type_mask,
                   lldb_private::TypeList &type_list) override;
 
   lldb_private::TypeSystem *
   GetTypeSystemForLanguage(lldb::LanguageType language) override;
 
   lldb_private::CompilerDeclContext FindNamespace(
-      const lldb_private::SymbolContext &sc,
       const lldb_private::ConstString &name,
       const lldb_private::CompilerDeclContext *parent_decl_ctx) override;
 
   lldb_private::ConstString GetPluginName() override;
 
   uint32_t GetPluginVersion() override;
 
   llvm::pdb::IPDBSession &GetPDBSession();

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

PDBASTParser *SymbolFilePDB::GetPDBAstParser() {
   if (!clang_type_system)
     return nullptr;
 
   return clang_type_system->GetPDBParser();
 }
 
 
 lldb_private::CompilerDeclContext SymbolFilePDB::FindNamespace(
-    const lldb_private::SymbolContext &sc,
     const lldb_private::ConstString &name,
     const lldb_private::CompilerDeclContext *parent_decl_ctx) {
   auto type_system = GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
   auto clang_type_system = llvm::dyn_cast_or_null<ClangASTContext>(type_system);
   if (!clang_type_system)
     return CompilerDeclContext();
 
   PDBASTParser *pdb = clang_type_system->GetPDBParser();

lldb/source/Symbol/SymbolVendor.cpp

if (module_sp) {
     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
     if (m_sym_file_ap.get())
       return m_sym_file_ap->GetTypes(sc_scope, type_mask, type_list);
   }
   return 0;
 }
 
 CompilerDeclContext
-SymbolVendor::FindNamespace(const SymbolContext &sc, const ConstString &name,
+SymbolVendor::FindNamespace(const ConstString &name,
                             const CompilerDeclContext *parent_decl_ctx) {
   CompilerDeclContext namespace_decl_ctx;
   ModuleSP module_sp(GetModule());
   if (module_sp) {
     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
     if (m_sym_file_ap.get())
-      namespace_decl_ctx =
-          m_sym_file_ap->FindNamespace(sc, name, parent_decl_ctx);
+      namespace_decl_ctx = m_sym_file_ap->FindNamespace(name, parent_decl_ctx);
   }
   return namespace_decl_ctx;
 }
 
 void SymbolVendor::Dump(Stream *s) {
   ModuleSP module_sp(GetModule());
   if (module_sp) {
     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());

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

 Error opts::symbols::findNamespaces(lldb_private::Module &Module) {
   SymbolVendor &Vendor = *Module.GetSymbolVendor();
   Expected<CompilerDeclContext> ContextOr = getDeclContext(Vendor);
   if (!ContextOr)
     return ContextOr.takeError();
   CompilerDeclContext *ContextPtr =
       ContextOr->IsValid() ? &*ContextOr : nullptr;
 
-  SymbolContext SC;
   CompilerDeclContext Result =
-      Vendor.FindNamespace(SC, ConstString(Name), ContextPtr);
+      Vendor.FindNamespace(ConstString(Name), ContextPtr);
   if (Result)
     outs() << "Found namespace: "
            << Result.GetScopeQualifiedName().GetStringRef() << "\n";
   else
     outs() << "Namespace not found.\n";
   return Error::success();
 }
 

lldb/unittests/SymbolFile/PDB/SymbolFilePDBTests.cpp

TEST_F(SymbolFilePDBTests, TestClassInNamespace) {
   FileSpec fspec(m_types_test_exe);
   ArchSpec aspec("i686-pc-windows");
   lldb::ModuleSP module = std::make_shared<Module>(fspec, aspec);
 
   SymbolVendor *plugin = module->GetSymbolVendor();
   SymbolFilePDB *symfile =
       static_cast<SymbolFilePDB *>(plugin->GetSymbolFile());
   llvm::pdb::IPDBSession &session = symfile->GetPDBSession();
-  SymbolContext sc;
   llvm::DenseSet<SymbolFile *> searched_files;
   TypeMap results;
 
   auto clang_ast_ctx = llvm::dyn_cast_or_null<ClangASTContext>(
       symfile->GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus));
   EXPECT_NE(nullptr, clang_ast_ctx);
 
   auto ast_ctx = clang_ast_ctx->getASTContext();
   EXPECT_NE(nullptr, ast_ctx);
 
   auto tu = ast_ctx->getTranslationUnitDecl();
   EXPECT_NE(nullptr, tu);
 
   symfile->ParseDeclsForContext(CompilerDeclContext(
       clang_ast_ctx, static_cast<clang::DeclContext *>(tu)));
 
-  auto ns_namespace = symfile->FindNamespace(sc, ConstString("NS"), nullptr);
+  auto ns_namespace = symfile->FindNamespace(ConstString("NS"), nullptr);
   EXPECT_TRUE(ns_namespace.IsValid());
 
+  SymbolContext sc;
   EXPECT_EQ(1u, symfile->FindTypes(sc, ConstString("NSClass"), &ns_namespace,
                                    false, 0, searched_files, results));
   EXPECT_EQ(1u, results.GetSize());
 
   lldb::TypeSP udt_type = results.GetTypeAtIndex(0);
   EXPECT_EQ(ConstString("NSClass"), udt_type->GetName());
 
   CompilerType compiler_type = udt_type->GetForwardCompilerType();