[NativePDB] Make GetParentDeclContext return an lldb type

[lanza]

Summary

We intend to make PdbAstBuilder abstract and implement
PdbAstBuilderClang along with any other languages that wish to use PDBs.
Thus, change GetParentDeclContext from returning a clang DeclContext to
a lldb_private::CompilerDeclContext.

source/Plugins/SymbolFile/NativePDB/PdbAstBuilder.h

 public:
   // Constructors and Destructors
   PdbAstBuilder(ObjectFile &obj, PdbIndex &index);
 
   lldb_private::CompilerDeclContext GetTranslationUnitDecl();
 
   lldb_private::CompilerDecl GetOrCreateDeclForUid(PdbSymUid uid);
   lldb_private::CompilerDeclContext GetOrCreateDeclContextForUid(PdbSymUid uid);
-  clang::DeclContext *GetParentDeclContext(PdbSymUid uid);
+  lldb_private::CompilerDeclContext GetParentDeclContext(PdbSymUid uid);
 
   clang::FunctionDecl *GetOrCreateFunctionDecl(PdbCompilandSymId func_id);
   clang::BlockDecl *GetOrCreateBlockDecl(PdbCompilandSymId block_id);
   clang::VarDecl *GetOrCreateVariableDecl(PdbCompilandSymId scope_id,
                                           PdbCompilandSymId var_id);
   clang::VarDecl *GetOrCreateVariableDecl(PdbGlobalSymId var_id);
   clang::TypedefNameDecl *GetOrCreateTypedefDecl(PdbGlobalSymId id);
   void ParseDeclsForContext(clang::DeclContext &context);

source/Plugins/SymbolFile/NativePDB/PdbAstBuilder.cpp

if (p.Segment == addr.segment && p.Offset == addr.offset)
     return p;
   return llvm::None;
 }
 
 clang::Decl *PdbAstBuilder::GetOrCreateSymbolForId(PdbCompilandSymId id) {
   CVSymbol cvs = m_index.ReadSymbolRecord(id);
 
   if (isLocalVariableType(cvs.kind())) {
-    clang::DeclContext *scope = GetParentDeclContext(id);
+    lldb_private::CompilerDeclContext decl_ctx = GetParentDeclContext(id);
+    auto scope =
+        static_cast<clang::DeclContext *>(decl_ctx.GetOpaqueDeclContext());
     clang::Decl *scope_decl = clang::Decl::castFromDeclContext(scope);
     PdbCompilandSymId scope_id(id.modi, m_decl_to_status[scope_decl].uid);
     return GetOrCreateVariableDecl(scope_id, id);
   }
 
   switch (cvs.kind()) {
   case S_GPROC32:
   case S_LPROC32:
PdbAstBuilder::GetParentDeclContextForSymbol(const CVSymbol &sym) {
   while (!name_components.empty()) {
     std::string ns = name_components.front()->toString();
     context = GetOrCreateNamespaceDecl(ns.c_str(), *context);
     name_components = name_components.drop_front();
   }
   return context;
 }
 
-clang::DeclContext *PdbAstBuilder::GetParentDeclContext(PdbSymUid uid) {
+lldb_private::CompilerDeclContext
+PdbAstBuilder::GetParentDeclContext(PdbSymUid uid) {
   // We must do this *without* calling GetOrCreate on the current uid, as
   // that would be an infinite recursion.
   switch (uid.kind()) {
   case PdbSymUidKind::CompilandSym: {
     llvm::Optional<PdbCompilandSymId> scope =
         FindSymbolScope(m_index, uid.asCompilandSym());
-    if (scope) {
-      lldb_private::CompilerDeclContext decl_ctx =
-          GetOrCreateDeclContextForUid(*scope);
-      auto ctx =
-          static_cast<clang::DeclContext *>(decl_ctx.GetOpaqueDeclContext());
-      return ctx;
-    }
+    if (scope)
+      return GetOrCreateDeclContextForUid(*scope);
 
     CVSymbol sym = m_index.ReadSymbolRecord(uid.asCompilandSym());
-    return GetParentDeclContextForSymbol(sym);
+    clang::DeclContext *decl_ctx = GetParentDeclContextForSymbol(sym);
+    return CompilerDeclContext(&m_clang, decl_ctx);
   }
   case PdbSymUidKind::Type: {
     // It could be a namespace, class, or global.  We don't support nested
     // functions yet.  Anyway, we just need to consult the parent type map.
     PdbTypeSymId type_id = uid.asTypeSym();
     auto iter = m_parent_types.find(type_id.index);
-    if (iter == m_parent_types.end()) {
-      auto decl_ctx = GetTranslationUnitDecl();
-      auto context =
-          static_cast<clang::DeclContext *>(decl_ctx.GetOpaqueDeclContext());
-      return context;
-    }
-    lldb_private::CompilerDeclContext decl_ctx =
-        GetOrCreateDeclContextForUid(PdbTypeSymId(iter->second));
-    auto ctx =
-        static_cast<clang::DeclContext *>(decl_ctx.GetOpaqueDeclContext());
-    return ctx;
+    if (iter == m_parent_types.end())
+      return GetTranslationUnitDecl();
+    return GetOrCreateDeclContextForUid(PdbTypeSymId(iter->second));
   }
   case PdbSymUidKind::FieldListMember:
     // In this case the parent DeclContext is the one for the class that this
     // member is inside of.
     break;
   case PdbSymUidKind::GlobalSym: {
     // If this refers to a compiland symbol, just recurse in with that symbol.
     // The only other possibilities are S_CONSTANT and S_UDT, in which case we
     // need to parse the undecorated name to figure out the scope, then look
     // that up in the TPI stream.  If it's found, it's a type, othewrise it's
     // a series of namespaces.
     // FIXME: do this.
     CVSymbol global = m_index.ReadSymbolRecord(uid.asGlobalSym());
     switch (global.kind()) {
     case SymbolKind::S_GDATA32:
-    case SymbolKind::S_LDATA32:
-      return GetParentDeclContextForSymbol(global);
+    case SymbolKind::S_LDATA32: {
+      clang::DeclContext *decl_ctx = GetParentDeclContextForSymbol(global);
+      return CompilerDeclContext(&m_clang, decl_ctx);
+    }
     case SymbolKind::S_PROCREF:
     case SymbolKind::S_LPROCREF: {
       ProcRefSym ref{global.kind()};
       llvm::cantFail(
           SymbolDeserializer::deserializeAs<ProcRefSym>(global, ref));
       PdbCompilandSymId cu_sym_id{ref.modi(), ref.SymOffset};
       return GetParentDeclContext(cu_sym_id);
     }
     case SymbolKind::S_CONSTANT:
-    case SymbolKind::S_UDT:
-      return CreateDeclInfoForUndecoratedName(getSymbolName(global)).first;
+    case SymbolKind::S_UDT: {
+      clang::DeclContext *decl_ctx =
+          CreateDeclInfoForUndecoratedName(getSymbolName(global)).first;
+      return CompilerDeclContext(&m_clang, decl_ctx);
+    }
     default:
       break;
     }
     break;
   }
   default:
     break;
   }
-  auto decl_ctx = GetTranslationUnitDecl();
-  auto context =
-      static_cast<clang::DeclContext *>(decl_ctx.GetOpaqueDeclContext());
-  return context;
+  return GetTranslationUnitDecl();
 }
 
 bool PdbAstBuilder::CompleteType(clang::QualType qt) {
   clang::TagDecl *tag = qt->getAsTagDecl();
   if (!tag)
     return false;
 
   return CompleteTagDecl(*tag);
return m_clang.GetUniqueNamespaceDeclaration(
       IsAnonymousNamespaceName(name) ? nullptr : name, &context);
 }
 
 clang::BlockDecl *
 PdbAstBuilder::GetOrCreateBlockDecl(PdbCompilandSymId block_id) {
   if (clang::Decl *decl = TryGetDecl(block_id))
     return llvm::dyn_cast<clang::BlockDecl>(decl);
 
-  clang::DeclContext *scope = GetParentDeclContext(block_id);
+  lldb_private::CompilerDeclContext decl_ctx = GetParentDeclContext(block_id);
+  auto scope =
+      static_cast<clang::DeclContext *>(decl_ctx.GetOpaqueDeclContext());
 
   clang::BlockDecl *block_decl = m_clang.CreateBlockDeclaration(scope);
   m_uid_to_decl.insert({toOpaqueUid(block_id), block_decl});
 
   DeclStatus status;
   status.resolved = true;
   status.uid = toOpaqueUid(block_id);
   m_decl_to_status.insert({block_decl, status});

 PdbAstBuilder::GetOrCreateTypedefDecl(PdbGlobalSymId id) {
   if (clang::Decl *decl = TryGetDecl(id))
     return llvm::dyn_cast<clang::TypedefNameDecl>(decl);
 
   CVSymbol sym = m_index.ReadSymbolRecord(id);
   lldbassert(sym.kind() == S_UDT);
   UDTSym udt = llvm::cantFail(SymbolDeserializer::deserializeAs<UDTSym>(sym));
 
-  clang::DeclContext *scope = GetParentDeclContext(id);
+  lldb_private::CompilerDeclContext decl_ctx = GetParentDeclContext(id);
+  auto scope =
+      static_cast<clang::DeclContext *>(decl_ctx.GetOpaqueDeclContext());
 
   PdbTypeSymId real_type_id{udt.Type, false};
   clang::QualType qt = GetOrCreateType(real_type_id);
 
   std::string uname = DropNameScope(udt.Name);
 
   CompilerType ct = m_clang.CreateTypedefType(ToCompilerType(qt), uname.c_str(),
                                               ToCompilerDeclContext(*scope));
clang::QualType PdbAstBuilder::GetOrCreateType(PdbTypeSymId type) {
   return qt;
 }
 
 clang::FunctionDecl *
 PdbAstBuilder::GetOrCreateFunctionDecl(PdbCompilandSymId func_id) {
   if (clang::Decl *decl = TryGetDecl(func_id))
     return llvm::dyn_cast<clang::FunctionDecl>(decl);
 
-  clang::DeclContext *parent = GetParentDeclContext(PdbSymUid(func_id));
+  lldb_private::CompilerDeclContext decl_ctx =
+      GetParentDeclContext(PdbSymUid(func_id));
+  auto parent =
+      static_cast<clang::DeclContext *>(decl_ctx.GetOpaqueDeclContext());
   std::string context_name;
   if (clang::NamespaceDecl *ns = llvm::dyn_cast<clang::NamespaceDecl>(parent)) {
     context_name = ns->getQualifiedNameAsString();
   } else if (clang::TagDecl *tag = llvm::dyn_cast<clang::TagDecl>(parent)) {
     context_name = tag->getQualifiedNameAsString();
   }
 
   CVSymbol cvs = m_index.ReadSymbolRecord(func_id);

source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp

SymbolFileNativePDB::GetDeclContextForUID(lldb::user_id_t uid) {
 
   auto clang_ctx =
       static_cast<clang::DeclContext *>(context.GetOpaqueDeclContext());
   return m_ast->ToCompilerDeclContext(*clang_ctx);
 }
 
 CompilerDeclContext
 SymbolFileNativePDB::GetDeclContextContainingUID(lldb::user_id_t uid) {
-  clang::DeclContext *context = m_ast->GetParentDeclContext(PdbSymUid(uid));
-  return m_ast->ToCompilerDeclContext(*context);
+  return m_ast->GetParentDeclContext(PdbSymUid(uid));
 }
 
 Type *SymbolFileNativePDB::ResolveTypeUID(lldb::user_id_t type_uid) {
   auto iter = m_types.find(type_uid);
   // lldb should not be passing us non-sensical type uids.  the only way it
   // could have a type uid in the first place is if we handed it out, in which
   // case we should know about the type.  However, that doesn't mean we've
   // instantiated it yet.  We can vend out a UID for a future type.  So if the