refactor: convert test to use split-file

Author: Nerixyz

lldb/source/Plugins/SymbolFile/NativePDB/PdbUtil.h

@@ -72,6 +72,14 @@ struct CVTagRecord {
     return cvunion.Name;
   }
 
+  CompilerContextKind contextKind() const {
+    if (m_kind == Struct || m_kind == Class)
+      return CompilerContextKind::ClassOrStruct;
+    if (m_kind == Enum)
+      return CompilerContextKind::Enum;
+    return CompilerContextKind::Union;
+  }
+
 private:
   CVTagRecord(llvm::codeview::ClassRecord &&c);
   CVTagRecord(llvm::codeview::UnionRecord &&u);

lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp

@@ -1727,14 +1727,15 @@ void SymbolFileNativePDB::FindTypes(const lldb_private::TypeQuery &query,
   m_type_base_names.GetValues(query.GetTypeBasename(), matches);
 
   for (uint32_t match_idx : matches) {
-    TypeSP type_sp = GetOrCreateType(TypeIndex(match_idx));
-    if (!type_sp)
+    std::vector context = GetContextForType(TypeIndex(match_idx));
+    if (context.empty())
       continue;
 
-    // We resolved a type. Get the fully qualified name to ensure it matches.
-    ConstString name = type_sp->GetQualifiedName();
-    TypeQuery type_match(name.GetStringRef(), TypeQueryOptions::e_exact_match);
-    if (query.ContextMatches(type_match.GetContextRef())) {
+    if (query.ContextMatches(context)) {
+      TypeSP type_sp = GetOrCreateType(TypeIndex(match_idx));
+      if (!type_sp)
+        continue;
+
       results.InsertUnique(type_sp);
       if (results.Done(query))
         return;
@@ -2362,3 +2363,52 @@ SymbolFileNativePDB::GetParentType(llvm::codeview::TypeIndex ti) {
     return std::nullopt;
   return parent_iter->second;
 }
+
+std::vector<CompilerContext>
+SymbolFileNativePDB::GetContextForType(TypeIndex ti) {
+  CVType type = m_index->tpi().getType(ti);
+  if (!IsTagRecord(type))
+    return {};
+
+  CVTagRecord tag = CVTagRecord::create(type);
+
+  std::optional<Type::ParsedName> parsed_name =
+      Type::GetTypeScopeAndBasename(tag.name());
+  if (!parsed_name)
+    return {{tag.contextKind(), ConstString(tag.name())}};
+
+  std::vector<CompilerContext> ctx;
+  // assume everything is a namespace at first
+  for (llvm::StringRef scope : parsed_name->scope) {
+    ctx.emplace_back(CompilerContextKind::Namespace, ConstString(scope));
+  }
+  // we know the kind of our own type
+  ctx.emplace_back(tag.contextKind(), ConstString(parsed_name->basename));
+
+  // try to find the kind of parents
+  for (auto &el : llvm::reverse(llvm::drop_end(ctx))) {
+    std::optional<TypeIndex> parent = GetParentType(ti);
+    if (!parent)
+      break;
+
+    ti = *parent;
+    type = m_index->tpi().getType(ti);
+    switch (type.kind()) {
+    case LF_CLASS:
+    case LF_STRUCTURE:
+    case LF_INTERFACE:
+      el.kind = CompilerContextKind::ClassOrStruct;
+      continue;
+    case LF_UNION:
+      el.kind = CompilerContextKind::Union;
+      continue;
+    case LF_ENUM:
+      el.kind = CompilerContextKind::Enum;
+      continue;
+    default:
+      break;
+    }
+    break;
+  }
+  return ctx;
+}

lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.h

@@ -258,6 +258,8 @@ class SymbolFileNativePDB : public SymbolFileCommon {
 
   void ParseInlineSite(PdbCompilandSymId inline_site_id, Address func_addr);
 
+  std::vector<CompilerContext> GetContextForType(llvm::codeview::TypeIndex ti);
+
   llvm::BumpPtrAllocator m_allocator;
 
   lldb::addr_t m_obj_load_address = 0;

lldb/source/Symbol/Type.cpp

@@ -134,9 +134,7 @@ bool TypeQuery::ContextMatches(
     if (ctx == ctx_end)
       return false; // Pattern too long.
 
-    if ((ctx->kind & CompilerContextKind::Namespace) ==
-            CompilerContextKind::Namespace &&
-        ctx->name.IsEmpty()) {
+    if (ctx->kind == CompilerContextKind::Namespace && ctx->name.IsEmpty()) {
       // We're matching an anonymous namespace. These are optional, so we check
       // if the pattern expects an anonymous namespace.
       if (pat->name.IsEmpty() && (pat->kind & CompilerContextKind::Namespace) ==
@@ -166,9 +164,7 @@ bool TypeQuery::ContextMatches(
   auto should_skip = [this](const CompilerContext &ctx) {
     if (ctx.kind == CompilerContextKind::Module)
       return GetIgnoreModules();
-    if ((ctx.kind & CompilerContextKind::Namespace) ==
-            CompilerContextKind::Namespace &&
-        ctx.name.IsEmpty())
+    if (ctx.kind == CompilerContextKind::Namespace && ctx.name.IsEmpty())
       return !GetStrictNamespaces();
     return false;
   };
@@ -820,10 +816,12 @@ Type::GetTypeScopeAndBasename(llvm::StringRef name) {
     case ':':
       if (prev_is_colon && template_depth == 0) {
         llvm::StringRef scope_name = name.slice(name_begin, pos.index() - 1);
-        // The itanium demangler uses this string to represent anonymous
+        // The demanglers use these strings to represent anonymous
         // namespaces. Convert it to a more language-agnostic form (which is
         // also used in DWARF).
-        if (scope_name == "(anonymous namespace)")
+        if (scope_name == "(anonymous namespace)" ||
+            scope_name == "`anonymous namespace'" ||
+            scope_name == "`anonymous-namespace'")
           scope_name = "";
         result.scope.push_back(scope_name);
         name_begin = pos.index() + 1;