Convert PDBASTParser::GetDeclContextForSymbol to 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 lldb::TypeSP
   CreateLLDBTypeFromPDBType(const llvm::pdb::PDBSymbol &type) = 0;
   virtual bool
   CompleteTypeFromPDB(lldb_private::CompilerType &compiler_type) = 0;
 
   virtual lldb_private::CompilerDecl
   GetDeclForSymbol(const llvm::pdb::PDBSymbol &symbol) = 0;
 
-  virtual clang::DeclContext *
+  virtual lldb_private::CompilerDeclContext
   GetDeclContextForSymbol(const llvm::pdb::PDBSymbol &symbol) = 0;
   virtual clang::DeclContext *
   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:
   ~PDBASTParserClang() override;
 
   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;
 
-  clang::DeclContext *
+  lldb_private::CompilerDeclContext
   GetDeclContextForSymbol(const llvm::pdb::PDBSymbol &symbol) override;
   clang::DeclContext *
   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;

source/Plugins/SymbolFile/PDB/PDBASTParserClang.cpp

default: {
     if (!type)
       return CompilerDecl();
 
     return CompilerDecl(&m_ast, m_uid_to_decl.lookup(sym_id));
   }
   }
 }
 
-clang::DeclContext *
+lldb_private::CompilerDeclContext
 PDBASTParserClang::GetDeclContextForSymbol(const llvm::pdb::PDBSymbol &symbol) {
   if (symbol.getSymTag() == PDB_SymType::Function) {
     clang::Decl *decl =
         static_cast<clang::Decl *>(GetDeclForSymbol(symbol).GetOpaqueDecl());
 
     clang::DeclContext *result =
         llvm::dyn_cast_or_null<clang::FunctionDecl>(decl);
 
     if (result)
       m_decl_context_to_uid[result] = symbol.getSymIndexId();
 
-    return result;
+    return CompilerDeclContext(&m_ast, result);
   }
 
   auto symbol_file = static_cast<SymbolFilePDB *>(m_ast.GetSymbolFile());
   if (!symbol_file)
-    return nullptr;
+    return CompilerDeclContext();
 
   auto type = symbol_file->ResolveTypeUID(symbol.getSymIndexId());
   if (!type)
-    return nullptr;
+    return CompilerDeclContext();
 
   clang::DeclContext *result =
       m_ast.GetDeclContextForType(type->GetForwardCompilerType());
 
   if (result)
     m_decl_context_to_uid[result] = symbol.getSymIndexId();
 
-  return result;
+  return CompilerDeclContext(&m_ast, result);
 }
 
 clang::DeclContext *PDBASTParserClang::GetDeclContextContainingSymbol(
     const llvm::pdb::PDBSymbol &symbol) {
   auto parent = GetClassOrFunctionParent(symbol);
   while (parent) {
     if (auto parent_context = GetDeclContextForSymbol(*parent))
-      return parent_context;
+      return static_cast<clang::DeclContext *>(
+          parent_context.GetOpaqueDeclContext());
 
     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).
 
clang::DeclContext *PDBASTParserClang::GetDeclContextContainingSymbol(
   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 =
                  children_enum->getNext()) {
         if (clang::DeclContext *child_context =
-                GetDeclContextForSymbol(*child)) {
+                static_cast<clang::DeclContext *>(
+                    GetDeclContextForSymbol(*child).GetOpaqueDeclContext())) {
           // Note that `GetDeclContextForSymbol' retrieves
           // a declaration context for functions and types only,
           // so if we are here then `child_context' is guaranteed
           // a function or a type declaration context.
           has_type_or_function_parent = true;
           curr_context = child_context;
         }
       }

source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp

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