[NativePDB] Make GetOrCreateDeclContextForUid 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 GetOrCreateDeclContextForUid from returning a clang
DeclContext to a lldb_private::CompilerDeclContext.

source/Plugins/SymbolFile/NativePDB/PdbAstBuilder.h

 class PdbAstBuilder {
 public:
   // Constructors and Destructors
   PdbAstBuilder(ObjectFile &obj, PdbIndex &index);
 
   lldb_private::CompilerDeclContext GetTranslationUnitDecl();
 
   lldb_private::CompilerDecl GetOrCreateDeclForUid(PdbSymUid uid);
-  clang::DeclContext *GetOrCreateDeclContextForUid(PdbSymUid uid);
+  lldb_private::CompilerDeclContext GetOrCreateDeclContextForUid(PdbSymUid uid);
   clang::DeclContext *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);

source/Plugins/SymbolFile/NativePDB/PdbAstBuilder.cpp

lldb_private::CompilerDecl PdbAstBuilder::GetOrCreateDeclForUid(PdbSymUid uid) {
   default:
     return CompilerDecl();
   }
   m_uid_to_decl[toOpaqueUid(uid)] = result;
   auto decl = CompilerDecl(&m_clang, result);
   return decl;
 }
 
-clang::DeclContext *PdbAstBuilder::GetOrCreateDeclContextForUid(PdbSymUid uid) {
+lldb_private::CompilerDeclContext
+PdbAstBuilder::GetOrCreateDeclContextForUid(PdbSymUid uid) {
   if (uid.kind() == PdbSymUidKind::CompilandSym) {
     if (uid.asCompilandSym().offset == 0) {
       auto decl_ctx = GetTranslationUnitDecl();
       auto context =
           static_cast<clang::DeclContext *>(decl_ctx.GetOpaqueDeclContext());
-      return context;
+      return CompilerDeclContext(&m_clang, context);
     }
   }
 
   lldb_private::CompilerDecl decl = GetOrCreateDeclForUid(uid);
   if (!decl)
-    return nullptr;
+    return CompilerDeclContext();
 
   auto clang_decl = static_cast<clang::Decl *>(decl.GetOpaqueDecl());
-  return clang::Decl::castToDeclContext(clang_decl);
+  auto clang_decl_ctx = clang::Decl::castToDeclContext(clang_decl);
+  return CompilerDeclContext(&m_clang, clang_decl_ctx);
 }
 
 std::pair<clang::DeclContext *, std::string>
 PdbAstBuilder::CreateDeclInfoForUndecoratedName(llvm::StringRef name) {
   MSVCUndecoratedNameParser parser(name);
   llvm::ArrayRef<MSVCUndecoratedNameSpecifier> specs = parser.GetSpecifiers();
 
   auto decl_ctx = GetTranslationUnitDecl();

 
 clang::DeclContext *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)
-      return GetOrCreateDeclContextForUid(*scope);
+    if (scope) {
+      lldb_private::CompilerDeclContext decl_ctx =
+          GetOrCreateDeclContextForUid(*scope);
+      auto ctx =
+          static_cast<clang::DeclContext *>(decl_ctx.GetOpaqueDeclContext());
+      return ctx;
+    }
 
     CVSymbol sym = m_index.ReadSymbolRecord(uid.asCompilandSym());
     return GetParentDeclContextForSymbol(sym);
   }
   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;
     }
-    return GetOrCreateDeclContextForUid(PdbTypeSymId(iter->second));
+    lldb_private::CompilerDeclContext decl_ctx =
+        GetOrCreateDeclContextForUid(PdbTypeSymId(iter->second));
+    auto ctx =
+        static_cast<clang::DeclContext *>(decl_ctx.GetOpaqueDeclContext());
+    return ctx;
   }
   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

 }
 
 clang::VarDecl *
 PdbAstBuilder::GetOrCreateVariableDecl(PdbCompilandSymId scope_id,
                                        PdbCompilandSymId var_id) {
   if (clang::Decl *decl = TryGetDecl(var_id))
     return llvm::dyn_cast<clang::VarDecl>(decl);
 
-  clang::DeclContext *scope = GetOrCreateDeclContextForUid(scope_id);
+  lldb_private::CompilerDeclContext lldb_scope =
+      GetOrCreateDeclContextForUid(scope_id);
+  auto scope =
+      static_cast<clang::DeclContext *>(lldb_scope.GetOpaqueDeclContext());
 
   CVSymbol sym = m_index.ReadSymbolRecord(var_id);
   return CreateVariableDecl(PdbSymUid(var_id), sym, *scope);
 }
 
 clang::VarDecl *PdbAstBuilder::GetOrCreateVariableDecl(PdbGlobalSymId var_id) {
   if (clang::Decl *decl = TryGetDecl(var_id))
     return llvm::dyn_cast<clang::VarDecl>(decl);

source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp

TypeSP SymbolFileNativePDB::CreateArrayType(PdbTypeSymId type_id,
   TypeSP array_sp = std::make_shared<lldb_private::Type>(
       toOpaqueUid(type_id), this, ConstString(), ar.Size, nullptr,
       LLDB_INVALID_UID, lldb_private::Type::eEncodingIsUID, decl, ct,
       lldb_private::Type::eResolveStateFull);
   array_sp->SetEncodingType(element_type.get());
   return array_sp;
 }
 
-
 TypeSP SymbolFileNativePDB::CreateFunctionType(PdbTypeSymId type_id,
                                                const MemberFunctionRecord &mfr,
                                                CompilerType ct) {
   Declaration decl;
   return std::make_shared<lldb_private::Type>(
       toOpaqueUid(type_id), this, ConstString(), 0, nullptr, LLDB_INVALID_UID,
       lldb_private::Type::eEncodingIsUID, decl, ct,
       lldb_private::Type::eResolveStateFull);
TypeSP SymbolFileNativePDB::CreateType(PdbTypeSymId type_id, CompilerType ct) {
 
   if (cvt.kind() == LF_PROCEDURE) {
     ProcedureRecord pr;
     llvm::cantFail(TypeDeserializer::deserializeAs<ProcedureRecord>(cvt, pr));
     return CreateProcedureType(type_id, pr, ct);
   }
   if (cvt.kind() == LF_MFUNCTION) {
     MemberFunctionRecord mfr;
-    llvm::cantFail(TypeDeserializer::deserializeAs<MemberFunctionRecord>(cvt, mfr));
+    llvm::cantFail(
+        TypeDeserializer::deserializeAs<MemberFunctionRecord>(cvt, mfr));
     return CreateFunctionType(type_id, mfr, ct);
   }
 
   return nullptr;
 }
 
 TypeSP SymbolFileNativePDB::CreateAndCacheType(PdbTypeSymId type_id) {
   // If they search for a UDT which is a forward ref, try and resolve the full

 
 uint32_t SymbolFileNativePDB::FindFunctions(const RegularExpression &regex,
                                             bool include_inlines, bool append,
                                             SymbolContextList &sc_list) {
   return 0;
 }
 
 uint32_t SymbolFileNativePDB::FindTypes(
-    ConstString name, const CompilerDeclContext *parent_decl_ctx,
-    bool append, uint32_t max_matches,
-    llvm::DenseSet<SymbolFile *> &searched_symbol_files, TypeMap &types) {
+    ConstString name, const CompilerDeclContext *parent_decl_ctx, bool append,
+    uint32_t max_matches, llvm::DenseSet<SymbolFile *> &searched_symbol_files,
+    TypeMap &types) {
   if (!append)
     types.Clear();
   if (!name)
     return 0;
 
   searched_symbol_files.clear();
   searched_symbol_files.insert(this);
 
lldb_private::CompilerDecl decl =
       m_ast->GetOrCreateDeclForUid(PdbSymUid(uid));
   auto clang_decl = static_cast<clang::Decl *>(decl.GetOpaqueDecl());
 
   return m_ast->ToCompilerDecl(*clang_decl);
 }
 
 CompilerDeclContext
 SymbolFileNativePDB::GetDeclContextForUID(lldb::user_id_t uid) {
-  clang::DeclContext *context =
+  lldb_private::CompilerDeclContext context =
       m_ast->GetOrCreateDeclContextForUid(PdbSymUid(uid));
   if (!context)
     return {};
 
-  return m_ast->ToCompilerDeclContext(*context);
+  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);
 }
 

 }
 
 llvm::Optional<SymbolFile::ArrayInfo>
 SymbolFileNativePDB::GetDynamicArrayInfoForUID(
     lldb::user_id_t type_uid, const lldb_private::ExecutionContext *exe_ctx) {
   return llvm::None;
 }
 
-
 bool SymbolFileNativePDB::CompleteType(CompilerType &compiler_type) {
   clang::QualType qt =
       clang::QualType::getFromOpaquePtr(compiler_type.GetOpaqueQualType());
 
   return m_ast->CompleteType(qt);
 }
 
 size_t SymbolFileNativePDB::GetTypes(lldb_private::SymbolContextScope *sc_scope,