[NativePDB] Make GetTranslationUnitDecl return an lldb CompilerDeclCtx

[lanza]

Summary

We intend to make PdbAstBuilder abstract and implement
PdbAstBuilderClang along with any other languages that wish to use
PDBs. This is the first step.

[lanza]

I know Zach isn't working on lldb anymore. Not sure who else to tag for NativePDB stuff. There is going to be a ton of commits similar to this to follow.

[aleksandr.urakov]

LGTM, thanks! Sorry for the long delay with the reply, I had days off.

You can add @amccarth to reviewers of NativePDB patches, he has taken over the work for Zachary.

[amccarth]

source/Plugins/SymbolFile/NativePDB/PdbAstBuilder.cpp

220

auto x = ...; return x; doesn't add any value. I'd just return the expression.

494

Should the return value become Expected<clang::DeclContext>?

499

The two statements above get repeated several times in this patch. Consider making a helper function like GetTranslationUnitDeclContext.

[lanza]

update

[lanza]

source/Plugins/SymbolFile/NativePDB/PdbAstBuilder.cpp

494

Technically, yes. But not because of this code. Cleaning up some of the pointers is on my list of to-dos for this file as well.

[amccarth]

LGTM.

source/Plugins/SymbolFile/NativePDB/PdbAstBuilder.cpp

494

OK. I brought it up because the goal seems to be to take a step toward making these APIs more general and thus abstractable, and tweaking the return value would seem (to me) to be part of that. If you're planning to make those kinds in a future patch, then I'm satisfied.

source/Plugins/SymbolFile/NativePDB/PdbAstBuilder.h

struct DeclStatus {
   bool resolved = false;
 };
 
 class PdbAstBuilder {
 public:
   // Constructors and Destructors
   PdbAstBuilder(ObjectFile &obj, PdbIndex &index);
 
-  clang::DeclContext &GetTranslationUnitDecl();
+  lldb_private::CompilerDeclContext GetTranslationUnitDecl();
 
   clang::Decl *GetOrCreateDeclForUid(PdbSymUid uid);
   clang::DeclContext *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,

source/Plugins/SymbolFile/NativePDB/PdbAstBuilder.cpp

static bool IsAnonymousNamespaceName(llvm::StringRef name) {
   return name == "`anonymous namespace'" || name == "`anonymous-namespace'";
 }
 
 PdbAstBuilder::PdbAstBuilder(ObjectFile &obj, PdbIndex &index)
     : m_index(index), m_clang(GetClangASTContext(obj)) {
   BuildParentMap();
 }
 
-clang::DeclContext &PdbAstBuilder::GetTranslationUnitDecl() {
-  return *m_clang.GetTranslationUnitDecl();
+lldb_private::CompilerDeclContext PdbAstBuilder::GetTranslationUnitDecl() {
+  auto decl_ctx =
+      CompilerDeclContext(&m_clang, m_clang.GetTranslationUnitDecl());
+  return decl_ctx;
 }
 
 std::pair<clang::DeclContext *, std::string>
 PdbAstBuilder::CreateDeclInfoForType(const TagRecord &record, TypeIndex ti) {
   // FIXME: Move this to GetDeclContextContainingUID.
   if (!record.hasUniqueName())
     return CreateDeclInfoForUndecoratedName(record.Name);
 
clang::Decl *PdbAstBuilder::GetOrCreateDeclForUid(PdbSymUid uid) {
   }
   default:
     return nullptr;
   }
   m_uid_to_decl[toOpaqueUid(uid)] = result;
   return result;
 }
 
 clang::DeclContext *PdbAstBuilder::GetOrCreateDeclContextForUid(PdbSymUid uid) {
   if (uid.kind() == PdbSymUidKind::CompilandSym) {
-    if (uid.asCompilandSym().offset == 0)
-      return &GetTranslationUnitDecl();
+    if (uid.asCompilandSym().offset == 0) {
+      auto decl_ctx = GetTranslationUnitDecl();
+      auto context =
+          static_cast<clang::DeclContext *>(decl_ctx.GetOpaqueDeclContext());
+      return context;
+    }
   }
 
   clang::Decl *decl = GetOrCreateDeclForUid(uid);
   if (!decl)
     return nullptr;
 
   return clang::Decl::castToDeclContext(decl);
 }
 
 std::pair<clang::DeclContext *, std::string>
 PdbAstBuilder::CreateDeclInfoForUndecoratedName(llvm::StringRef name) {
   MSVCUndecoratedNameParser parser(name);
   llvm::ArrayRef<MSVCUndecoratedNameSpecifier> specs = parser.GetSpecifiers();
 
-  clang::DeclContext *context = &GetTranslationUnitDecl();
+  auto decl_ctx = GetTranslationUnitDecl();
+  auto context =
+      static_cast<clang::DeclContext *>(decl_ctx.GetOpaqueDeclContext());
 
   llvm::StringRef uname = specs.back().GetBaseName();
   specs = specs.drop_back();
   if (specs.empty())
     return {context, name};
 
   llvm::StringRef scope_name = specs.back().GetFullName();
 
PdbAstBuilder::GetParentDeclContextForSymbol(const CVSymbol &sym) {
   llvm::Optional<PublicSym32> pub =
       FindPublicSym(addr, m_index.symrecords(), m_index.publics());
   if (!pub)
     return CreateDeclInfoForUndecoratedName(getSymbolName(sym)).first;
 
   llvm::ms_demangle::Demangler demangler;
   StringView name{pub->Name.begin(), pub->Name.size()};
   llvm::ms_demangle::SymbolNode *node = demangler.parse(name);
-  if (!node)
-    return &GetTranslationUnitDecl();
+  if (!node) {
+    auto decl_ctx = GetTranslationUnitDecl();
+    auto context =
+        static_cast<clang::DeclContext *>(decl_ctx.GetOpaqueDeclContext());
+    return context;
+  }
   llvm::ArrayRef<llvm::ms_demangle::Node *> name_components{
       node->Name->Components->Nodes, node->Name->Components->Count - 1};
 
   if (!name_components.empty()) {
     // Render the current list of scope nodes as a fully qualified name, and
     // look it up in the debug info as a type name.  If we find something,
     // this is a type (which may itself be prefixed by a namespace).  If we
     // don't, this is a list of namespaces.
     std::string qname = RenderScopeList(name_components);
     std::vector<TypeIndex> matches = m_index.tpi().findRecordsByName(qname);
     while (!matches.empty()) {
       clang::QualType qt = GetOrCreateType(matches.back());
       clang::TagDecl *tag = qt->getAsTagDecl();
       if (tag)
         return clang::TagDecl::castToDeclContext(tag);
       matches.pop_back();
     }
   }
 
   // It's not a type.  It must be a series of namespaces.
-  clang::DeclContext *context = &GetTranslationUnitDecl();
+  auto decl_ctx = GetTranslationUnitDecl();
+  auto context =
+      static_cast<clang::DeclContext *>(decl_ctx.GetOpaqueDeclContext());
   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;
 }
 
case PdbSymUidKind::CompilandSym: {
     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())
-      return &GetTranslationUnitDecl();
+    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));
   }
   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.
case PdbSymUidKind::GlobalSym: {
     default:
       break;
     }
     break;
   }
   default:
     break;
   }
-  return &GetTranslationUnitDecl();
+  auto decl_ctx = GetTranslationUnitDecl();
+  auto context =
+      static_cast<clang::DeclContext *>(decl_ctx.GetOpaqueDeclContext());
+  return context;
 }
 
 bool PdbAstBuilder::CompleteType(clang::QualType qt) {
   clang::TagDecl *tag = qt->getAsTagDecl();
   if (!tag)
     return false;
 
   return CompleteTagDecl(*tag);
PdbAstBuilder::GetOrCreateVariableDecl(PdbCompilandSymId scope_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);
 
   CVSymbol sym = m_index.ReadSymbolRecord(var_id);
-  return CreateVariableDecl(PdbSymUid(var_id), sym, GetTranslationUnitDecl());
+  auto decl_ctx = GetTranslationUnitDecl();
+  auto context =
+      static_cast<clang::DeclContext *>(decl_ctx.GetOpaqueDeclContext());
+  return CreateVariableDecl(PdbSymUid(var_id), sym, *context);
 }
 
 clang::TypedefNameDecl *
 PdbAstBuilder::GetOrCreateTypedefDecl(PdbGlobalSymId id) {
   if (clang::Decl *decl = TryGetDecl(id))
     return llvm::dyn_cast<clang::TypedefNameDecl>(decl);
 
   CVSymbol sym = m_index.ReadSymbolRecord(id);