Convert PDBASTParser::GetDCContainingSymbol to be non-clang specific

[lanza]

Summary

We are attempting to make PDBASTParser frontend agnostic to enable
multiple languages be able to produce PDB for lldb's consumption. Thus,
remove clang specific behavior.

source/Plugins/SymbolFile/PDB/PDBASTParser.h

public:
   virtual bool
   CompleteTypeFromPDB(lldb_private::CompilerType &compiler_type) = 0;
 
   virtual lldb_private::CompilerDecl
   GetDeclForSymbol(const llvm::pdb::PDBSymbol &symbol) = 0;
 
   virtual lldb_private::CompilerDeclContext
   GetDeclContextForSymbol(const llvm::pdb::PDBSymbol &symbol) = 0;
-  virtual clang::DeclContext *
+  virtual lldb_private::CompilerDeclContext
   GetDeclContextContainingSymbol(const llvm::pdb::PDBSymbol &symbol) = 0;
 
   virtual void
   ParseDeclsForDeclContext(const clang::DeclContext *decl_context) = 0;
 
   virtual clang::NamespaceDecl *
   FindNamespaceDecl(const clang::DeclContext *parent, llvm::StringRef name) = 0;
 };
 
 #endif // LLDB_PLUGINS_SYMBOLFILE_PDB_PDBASTPARSER_H

source/Plugins/SymbolFile/PDB/PDBASTParserClang.h

public:
   lldb::TypeSP CreateLLDBTypeFromPDBType(const llvm::pdb::PDBSymbol &type) override;
   bool CompleteTypeFromPDB(lldb_private::CompilerType &compiler_type) override;
 
   lldb_private::CompilerDecl
   GetDeclForSymbol(const llvm::pdb::PDBSymbol &symbol) override;
 
   lldb_private::CompilerDeclContext
   GetDeclContextForSymbol(const llvm::pdb::PDBSymbol &symbol) override;
-  clang::DeclContext *
+  lldb_private::CompilerDeclContext
   GetDeclContextContainingSymbol(const llvm::pdb::PDBSymbol &symbol) override;
 
   void ParseDeclsForDeclContext(const clang::DeclContext *decl_context) override;
 
   clang::NamespaceDecl *FindNamespaceDecl(const clang::DeclContext *parent,
                                           llvm::StringRef name) override;
 
   lldb_private::ClangASTImporter &GetClangASTImporter() {

source/Plugins/SymbolFile/PDB/PDBASTParserClang.cpp

case PDB_SymType::UDT: {
     if (udt->getLength() == 0)
       return nullptr;
 
     // Ignore unnamed-tag UDTs.
     std::string name = MSVCUndecoratedNameParser::DropScope(udt->getName());
     if (name.empty())
       return nullptr;
 
-    auto decl_context = GetDeclContextContainingSymbol(type);
+    auto comp_decl_context = GetDeclContextContainingSymbol(type);
+    auto decl_context = static_cast<clang::DeclContext *>(
+        comp_decl_context.GetOpaqueDeclContext());
 
     // Check if such an UDT already exists in the current context.
     // This may occur with const or volatile types. There are separate type
     // symbols in PDB for types with const or volatile modifiers, but we need
     // to create only one declaration for them all.
     Type::ResolveStateTag type_resolve_state_tag;
     CompilerType clang_type = m_ast.GetTypeForIdentifier<clang::CXXRecordDecl>(
         ConstString(name), decl_context);
return std::make_shared<lldb_private::Type>(
         type_resolve_state_tag);
   } break;
   case PDB_SymType::Enum: {
     auto enum_type = llvm::dyn_cast<PDBSymbolTypeEnum>(&type);
     assert(enum_type);
 
     std::string name =
         MSVCUndecoratedNameParser::DropScope(enum_type->getName());
-    auto decl_context = GetDeclContextContainingSymbol(type);
+    auto comp_decl_context = GetDeclContextContainingSymbol(type);
+    auto decl_context = static_cast<clang::DeclContext *>(
+        comp_decl_context.GetOpaqueDeclContext());
     uint64_t bytes = enum_type->getLength();
 
     // Check if such an enum already exists in the current context
     CompilerType ast_enum = m_ast.GetTypeForIdentifier<clang::EnumDecl>(
         ConstString(name), decl_context);
     if (!ast_enum.IsValid()) {
       auto underlying_type_up = enum_type->getUnderlyingType();
       if (!underlying_type_up)
case PDB_SymType::Typedef: {
 
     lldb_private::Type *target_type =
         m_ast.GetSymbolFile()->ResolveTypeUID(type_def->getTypeId());
     if (!target_type)
       return nullptr;
 
     std::string name =
         MSVCUndecoratedNameParser::DropScope(type_def->getName());
-    auto decl_ctx = GetDeclContextContainingSymbol(type);
+    auto comp_decl_ctx = GetDeclContextContainingSymbol(type);
+    auto decl_ctx =
+        static_cast<clang::DeclContext *>(comp_decl_ctx.GetOpaqueDeclContext());
 
     // Check if such a typedef already exists in the current context
     CompilerType ast_typedef =
         m_ast.GetTypeForIdentifier<clang::TypedefNameDecl>(ConstString(name),
                                                            decl_ctx);
     if (!ast_typedef.IsValid()) {
       CompilerType target_ast_type = target_type->GetFullCompilerType();
 
PDBASTParserClang::GetDeclForSymbol(const llvm::pdb::PDBSymbol &symbol) {
 
   // If we are here, then the symbol is not belonging to a class and is not
   // contained in the cache. So create a declaration for it.
   switch (symbol.getSymTag()) {
   case PDB_SymType::Data: {
     auto data = llvm::dyn_cast<PDBSymbolData>(&symbol);
     assert(data);
 
-    auto decl_context = GetDeclContextContainingSymbol(symbol);
+    auto comp_decl_context = GetDeclContextContainingSymbol(symbol);
+    auto decl_context = static_cast<clang::DeclContext *>(
+        comp_decl_context.GetOpaqueDeclContext());
     assert(decl_context);
 
     // May be the current context is a class really, but we haven't found
     // any class parent. This happens e.g. in the case of class static
     // variables - they has two symbols, one is a child of the class when
     // another is a child of the exe. So always complete the parent and use
     // an existing declaration if possible.
     if (auto parent_decl = llvm::dyn_cast_or_null<clang::TagDecl>(decl_context))
case PDB_SymType::Data: {
     m_uid_to_decl[sym_id] = decl;
 
     return CompilerDecl(&m_ast, decl);
   }
   case PDB_SymType::Function: {
     auto func = llvm::dyn_cast<PDBSymbolFunc>(&symbol);
     assert(func);
 
-    auto decl_context = GetDeclContextContainingSymbol(symbol);
+    auto comp_decl_context = GetDeclContextContainingSymbol(symbol);
+    auto decl_context = static_cast<clang::DeclContext *>(
+        comp_decl_context.GetOpaqueDeclContext());
     assert(decl_context);
 
     std::string name = MSVCUndecoratedNameParser::DropScope(func->getName());
 
     Type *type = symbol_file->ResolveTypeUID(sym_id);
     if (!type)
       return CompilerDecl();
 
clang::DeclContext *result =
       m_ast.GetDeclContextForType(type->GetForwardCompilerType());
 
   if (result)
     m_decl_context_to_uid[result] = symbol.getSymIndexId();
 
   return CompilerDeclContext(&m_ast, result);
 }
 
-clang::DeclContext *PDBASTParserClang::GetDeclContextContainingSymbol(
+lldb_private::CompilerDeclContext
+PDBASTParserClang::GetDeclContextContainingSymbol(
     const llvm::pdb::PDBSymbol &symbol) {
   auto parent = GetClassOrFunctionParent(symbol);
   while (parent) {
     if (auto parent_context = GetDeclContextForSymbol(*parent))
-      return static_cast<clang::DeclContext *>(
-          parent_context.GetOpaqueDeclContext());
+      return parent_context;
 
     parent = GetClassOrFunctionParent(*parent);
   }
 
   // We can't find any class or function parent of the symbol. So analyze
   // the full symbol name. The symbol may be belonging to a namespace
   // or function (or even to a class if it's e.g. a static variable symbol).
 
   // TODO: Make clang to emit full names for variables in namespaces
   // (as MSVC does)
 
   std::string name(symbol.getRawSymbol().getName());
   MSVCUndecoratedNameParser parser(name);
   llvm::ArrayRef<MSVCUndecoratedNameSpecifier> specs = parser.GetSpecifiers();
   if (specs.empty())
-    return m_ast.GetTranslationUnitDecl();
+    return CompilerDeclContext(&m_ast, m_ast.GetTranslationUnitDecl());
 
   auto symbol_file = static_cast<SymbolFilePDB *>(m_ast.GetSymbolFile());
   if (!symbol_file)
-    return m_ast.GetTranslationUnitDecl();
+    return CompilerDeclContext(&m_ast, m_ast.GetTranslationUnitDecl());
 
   auto global = symbol_file->GetPDBSession().getGlobalScope();
   if (!global)
-    return m_ast.GetTranslationUnitDecl();
+    return CompilerDeclContext(&m_ast, m_ast.GetTranslationUnitDecl());
 
   bool has_type_or_function_parent = false;
   clang::DeclContext *curr_context = m_ast.GetTranslationUnitDecl();
   for (std::size_t i = 0; i < specs.size() - 1; i++) {
     // Check if there is a function or a type with the current context's name.
     if (std::unique_ptr<IPDBEnumSymbols> children_enum = global->findChildren(
             PDB_SymType::None, specs[i].GetFullName(), NS_CaseSensitive)) {
       while (IPDBEnumChildren<PDBSymbol>::ChildTypePtr child =
if (!has_type_or_function_parent) {
 
       m_parent_to_namespaces[curr_context].insert(namespace_decl);
       m_namespaces.insert(namespace_decl);
 
       curr_context = namespace_decl;
     }
   }
 
-  return curr_context;
+  return CompilerDeclContext(&m_ast, curr_context);
 }
 
 void PDBASTParserClang::ParseDeclsForDeclContext(
     const clang::DeclContext *decl_context) {
   auto symbol_file = static_cast<SymbolFilePDB *>(m_ast.GetSymbolFile());
   if (!symbol_file)
     return;
 

source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp

SymbolFilePDB::GetDeclContextContainingUID(lldb::user_id_t uid) {
 
   auto symbol = m_session_up->getSymbolById(uid);
   if (!symbol)
     return CompilerDeclContext();
 
   auto decl_context = pdb->GetDeclContextContainingSymbol(*symbol);
   assert(decl_context);
 
-  return CompilerDeclContext(clang_ast_ctx, decl_context);
+  return decl_context;
 }
 
 void SymbolFilePDB::ParseDeclsForContext(
     lldb_private::CompilerDeclContext decl_ctx) {
   ClangASTContext *clang_ast_ctx = llvm::dyn_cast_or_null<ClangASTContext>(
       GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus));
   if (!clang_ast_ctx)
     return;