Generalize FindTypes with CompilerContext to support fuzzy lookup

[aprantl]

Summary

This patch generalizes the FindTypes with CompilerContext interface to support looking up a type of unknown kind by name, as well as looking up a type inside an unspecified submodule. These features are motivated by the Swift branch, but are fully tested via unit tests and lldb-test on llvm.org.
Specifically, this patch adds an AnyModule and an AnyType CompilerContext kind.

[labath]

I don't have any context or opinion on the high level functionality, but can we please not use inheritance in this way? Though I have done similar things in the past, I am not really proud of them. It looks like the matching code can be just as easily be implemented as a free function...

lldb/source/Symbol/Type.cpp

54–60 ↗

(On Diff #216289)

it looks like you should use context_chain.end() instead of end().
Also, all of this probably boils down to it = std::find_if(it, context_chain.end(), [](??? cc) { return cc.kind != Module; });

[aprantl]

Address feedback from Pavel.

[JDevlieghere]

LGTM

lldb/include/lldb/Symbol/Type.h

42 ↗

(On Diff #216425)

nit: reflow

lldb/trunk/include/lldb/Symbol/SymbolFile.h

public:
   virtual uint32_t FindFunctions(const RegularExpression &regex,
                                  bool include_inlines, bool append,
                                  SymbolContextList &sc_list);
   virtual uint32_t
   FindTypes(ConstString name, const CompilerDeclContext *parent_decl_ctx,
             bool append, uint32_t max_matches,
             llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
             TypeMap &types);
-  virtual size_t FindTypes(const std::vector<CompilerContext> &context,
-                           bool append, TypeMap &types);
+  virtual size_t FindTypes(llvm::ArrayRef<CompilerContext> pattern, bool append,
+                           TypeMap &types);
 
   virtual void
   GetMangledNamesForFunction(const std::string &scope_qualified_name,
                              std::vector<ConstString> &mangled_names);
 
   virtual size_t GetTypes(lldb_private::SymbolContextScope *sc_scope,
                           lldb::TypeClass type_mask,
                           lldb_private::TypeList &type_list) = 0;

lldb/trunk/include/lldb/Symbol/Type.h

 #include "lldb/Utility/UserID.h"
 #include "lldb/lldb-private.h"
 
 #include "llvm/ADT/APSInt.h"
 
 #include <set>
 
 namespace lldb_private {
-// CompilerContext allows an array of these items to be passed to perform
-// detailed lookups in SymbolVendor and SymbolFile functions.
+
+/// CompilerContext allows an array of these items to be passed to perform
+/// detailed lookups in SymbolVendor and SymbolFile functions.
 struct CompilerContext {
-  CompilerContext(CompilerContextKind t, ConstString n)
-      : type(t), name(n) {}
+  CompilerContext(CompilerContextKind t, ConstString n) : kind(t), name(n) {}
 
   bool operator==(const CompilerContext &rhs) const {
-    return type == rhs.type && name == rhs.name;
+    return kind == rhs.kind && name == rhs.name;
   }
+  bool operator!=(const CompilerContext &rhs) const { return !(*this == rhs); }
 
   void Dump() const;
 
-  CompilerContextKind type;
+  CompilerContextKind kind;
   ConstString name;
 };
 
+/// Match \p context_chain against \p pattern, which may contain "Any"
+/// kinds. The \p context_chain should *not* contain any "Any" kinds.
+bool contextMatches(llvm::ArrayRef<CompilerContext> context_chain,
+                    llvm::ArrayRef<CompilerContext> pattern);
+
 class SymbolFileType : public std::enable_shared_from_this<SymbolFileType>,
                        public UserID {
 public:
   SymbolFileType(SymbolFile &symbol_file, lldb::user_id_t uid)
       : UserID(uid), m_symbol_file(symbol_file) {}
 
   SymbolFileType(SymbolFile &symbol_file, const lldb::TypeSP &type_sp);
 

lldb/trunk/include/lldb/lldb-private-enumerations.h

Status,  // There is an error with the current line and it needs to be
            // before it can be accepted
   Done     // Lines are complete
 };
 
 // Boolean result of running a Type Validator
 enum class TypeValidatorResult : bool { Success = true, Failure = false };
 
 // Enumerations that can be used to specify scopes types when looking up types.
-enum class CompilerContextKind {
+enum class CompilerContextKind : uint16_t {
   Invalid = 0,
-  TranslationUnit,
-  Module,
-  Namespace,
-  Class,
-  Structure,
-  Union,
-  Function,
-  Variable,
-  Enumeration,
-  Typedef
+  TranslationUnit = 1,
+  Module = 1 << 1,
+  Namespace = 1 << 2,
+  Class = 1 << 3,
+  Struct = 1 << 4,
+  Union = 1 << 5,
+  Function = 1 << 6,
+  Variable = 1 << 7,
+  Enum = 1 << 8,
+  Typedef = 1 << 9,
+
+  Any = 1 << 15,
+  /// Match 0..n nested modules.
+  AnyModule = Any | Module,
+  /// Match any type.
+  AnyType = Any | Class | Struct | Union | Enum | Typedef
 };
 
 // Enumerations that can be used to specify the kind of metric we're looking at
 // when collecting stats.
 enum StatisticKind {
   ExpressionSuccessful = 0,
   ExpressionFailure = 1,
   FrameVarSuccess = 2,

lldb/trunk/lit/SymbolFile/DWARF/compilercontext.ll

 ; Test finding types by CompilerContext.
 ; RUN: llc %s -filetype=obj -o %t.o
-; RUN: lldb-test symbols %t.o -find=type -compiler-context="Module:CModule,Module:SubModule,Structure:FromSubmodule" | FileCheck %s
-;
+; RUN: lldb-test symbols %t.o -find=type \
+; RUN:   -compiler-context="Module:CModule,Module:SubModule,Struct:FromSubmoduleX" \
+; RUN:   | FileCheck %s --check-prefix=NORESULTS
+; RUN: lldb-test symbols %t.o -find=type \
+; RUN:   -compiler-context="Module:CModule,Module:SubModule,Struct:FromSubmodule" \
+; RUN:   | FileCheck %s
+; RUN: lldb-test symbols %t.o -find=type \
+; RUN:   -compiler-context="Module:CModule,AnyModule:*,Struct:FromSubmodule" \
+; RUN:   | FileCheck %s
+; RUN: lldb-test symbols %t.o -find=type \
+; RUN:   -compiler-context="AnyModule:*,Struct:FromSubmodule" \
+; RUN:   | FileCheck %s
+; RUN: lldb-test symbols %t.o -find=type \
+; RUN:   -compiler-context="Module:CModule,Module:SubModule,AnyType:FromSubmodule" \
+; RUN:   | FileCheck %s
 ;
+; NORESULTS: Found 0 types
 ; CHECK: Found 1 types:
 ; CHECK: struct FromSubmodule {
 ; CHECK-NEXT:     unsigned int x;
 ; CHECK-NEXT:     unsigned int y;
 ; CHECK-NEXT:     unsigned int z;
 ; CHECK-NEXT: }
 
 source_filename = "/t.c"

lldb/trunk/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.h

uint32_t FindFunctions(const RegularExpression &regex, bool include_inlines,
                          bool append, SymbolContextList &sc_list) override;
 
   uint32_t FindTypes(ConstString name,
                      const CompilerDeclContext *parent_decl_ctx, bool append,
                      uint32_t max_matches,
                      llvm::DenseSet<SymbolFile *> &searched_symbol_files,
                      TypeMap &types) override;
 
-  size_t FindTypes(const std::vector<CompilerContext> &context, bool append,
+  size_t FindTypes(llvm::ArrayRef<CompilerContext> pattern, bool append,
                    TypeMap &types) override;
 
   llvm::Expected<TypeSystem &>
   GetTypeSystemForLanguage(lldb::LanguageType language) override {
     return llvm::make_error<llvm::StringError>(
         "SymbolFileBreakpad does not support GetTypeSystemForLanguage",
         llvm::inconvertibleErrorCode());
   }

lldb/trunk/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.cpp

uint32_t SymbolFileBreakpad::FindTypes(
     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();
   return types.GetSize();
 }
 
-size_t
-SymbolFileBreakpad::FindTypes(const std::vector<CompilerContext> &context,
+size_t SymbolFileBreakpad::FindTypes(llvm::ArrayRef<CompilerContext> pattern,
                                      bool append, TypeMap &types) {
   if (!append)
     types.Clear();
   return types.GetSize();
 }
 
 void SymbolFileBreakpad::AddSymbols(Symtab &symtab) {
   Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_SYMBOLS);
   Module &module = *m_objfile_sp->GetModule();

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

 TypeSP DWARFASTParserClang::ParseTypeFromDWO(const DWARFDIE &die, Log *log) {
   ModuleSP dwo_module_sp = die.GetContainingDWOModule();
   if (!dwo_module_sp)
     return TypeSP();
 
   // If this type comes from a Clang module, look in the DWARF section
   // of the pcm file in the module cache. Clang generates DWO skeleton
   // units as breadcrumbs to find them.
-  std::vector<CompilerContext> decl_context;
+  llvm::SmallVector<CompilerContext, 4> decl_context;
   die.GetDeclContext(decl_context);
   TypeMap dwo_types;
 
-  if (!dwo_module_sp->GetSymbolFile()->FindTypes(decl_context, true,
+  if (!dwo_module_sp->GetSymbolFile()->FindTypes({decl_context}, true,
                                                  dwo_types)) {
     if (!IsClangModuleFwdDecl(die))
       return TypeSP();
 
     // Since this this type is defined in one of the Clang modules imported by
     // this symbol file, search all of them.
     auto &sym_file = die.GetCU()->GetSymbolFileDWARF();
     for (const auto &name_module : sym_file.getExternalTypeModules()) {
       if (!name_module.second)
         continue;
-      if (name_module.second->GetSymbolFile()->FindTypes(decl_context, true,
+      if (name_module.second->GetSymbolFile()->FindTypes({decl_context}, true,
                                                          dwo_types))
         break;
     }
   }
 
   if (dwo_types.GetSize() != 1)
     return TypeSP();
 

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFDIE.h

public:
 
   // DeclContext related functions
   std::vector<DWARFDIE> GetDeclContextDIEs() const;
 
   void GetDWARFDeclContext(DWARFDeclContext &dwarf_decl_ctx) const;
 
   /// Return this DIE's decl context as it is needed to look up types
   /// in Clang's -gmodules debug info format.
-  void
-  GetDeclContext(std::vector<lldb_private::CompilerContext> &context) const;
+  void GetDeclContext(
+      llvm::SmallVectorImpl<lldb_private::CompilerContext> &context) const;
 
   // Getting attribute values from the DIE.
   //
   // GetAttributeValueAsXXX() functions should only be used if you are
   // looking for one or two attributes on a DIE. If you are trying to
   // parse all attributes, use GetAttributes (...) instead
   DWARFDIE
   GetAttributeValueAsReferenceDIE(const dw_attr_t attr) const;

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFDIE.cpp

void DWARFDIE::GetDWARFDeclContext(DWARFDeclContext &dwarf_decl_ctx) const {
   if (IsValid()) {
     dwarf_decl_ctx.SetLanguage(GetLanguage());
     m_die->GetDWARFDeclContext(GetCU(), dwarf_decl_ctx);
   } else {
     dwarf_decl_ctx.Clear();
   }
 }
 
-void DWARFDIE::GetDeclContext(std::vector<CompilerContext> &context) const {
+void DWARFDIE::GetDeclContext(
+    llvm::SmallVectorImpl<lldb_private::CompilerContext> &context) const {
   const dw_tag_t tag = Tag();
   if (tag == DW_TAG_compile_unit || tag == DW_TAG_partial_unit)
     return;
   DWARFDIE parent = GetParent();
   if (parent)
     parent.GetDeclContext(context);
   switch (tag) {
   case DW_TAG_module:
-    context.push_back(
-        CompilerContext(CompilerContextKind::Module, ConstString(GetName())));
+    context.push_back({CompilerContextKind::Module, ConstString(GetName())});
     break;
   case DW_TAG_namespace:
-    context.push_back(CompilerContext(CompilerContextKind::Namespace,
-                                      ConstString(GetName())));
+    context.push_back({CompilerContextKind::Namespace, ConstString(GetName())});
     break;
   case DW_TAG_structure_type:
-    context.push_back(CompilerContext(CompilerContextKind::Structure,
-                                      ConstString(GetName())));
+    context.push_back({CompilerContextKind::Struct, ConstString(GetName())});
     break;
   case DW_TAG_union_type:
-    context.push_back(
-        CompilerContext(CompilerContextKind::Union, ConstString(GetName())));
+    context.push_back({CompilerContextKind::Union, ConstString(GetName())});
     break;
   case DW_TAG_class_type:
-    context.push_back(
-        CompilerContext(CompilerContextKind::Class, ConstString(GetName())));
+    context.push_back({CompilerContextKind::Class, ConstString(GetName())});
     break;
   case DW_TAG_enumeration_type:
-    context.push_back(CompilerContext(CompilerContextKind::Enumeration,
-                                      ConstString(GetName())));
+    context.push_back({CompilerContextKind::Enum, ConstString(GetName())});
     break;
   case DW_TAG_subprogram:
-    context.push_back(CompilerContext(CompilerContextKind::Function,
-                                      ConstString(GetPubname())));
+    context.push_back(
+        {CompilerContextKind::Function, ConstString(GetPubname())});
     break;
   case DW_TAG_variable:
-    context.push_back(CompilerContext(CompilerContextKind::Variable,
-                                      ConstString(GetPubname())));
+    context.push_back(
+        {CompilerContextKind::Variable, ConstString(GetPubname())});
     break;
   case DW_TAG_typedef:
-    context.push_back(
-        CompilerContext(CompilerContextKind::Typedef, ConstString(GetName())));
+    context.push_back({CompilerContextKind::Typedef, ConstString(GetName())});
     break;
   default:
     break;
   }
 }
 
 DWARFDIE
 DWARFDIE::GetParentDeclContextDIE() const {

lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

public:
 
   uint32_t
   FindTypes(lldb_private::ConstString name,
             const lldb_private::CompilerDeclContext *parent_decl_ctx,
             bool append, uint32_t max_matches,
             llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
             lldb_private::TypeMap &types) override;
 
-  size_t FindTypes(const std::vector<lldb_private::CompilerContext> &context,
+  size_t FindTypes(llvm::ArrayRef<lldb_private::CompilerContext> pattern,
                    bool append, lldb_private::TypeMap &types) override;
 
   size_t GetTypes(lldb_private::SymbolContextScope *sc_scope,
                   lldb::TypeClass type_mask,
                   lldb_private::TypeList &type_list) override;
 
   llvm::Expected<lldb_private::TypeSystem &>
   GetTypeSystemForLanguage(lldb::LanguageType language) override;

lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

for (const auto &pair : m_external_type_modules) {
         }
       }
     }
   }
 
   return num_die_matches;
 }
 
-size_t SymbolFileDWARF::FindTypes(const std::vector<CompilerContext> &context,
+size_t SymbolFileDWARF::FindTypes(llvm::ArrayRef<CompilerContext> pattern,
                                   bool append, TypeMap &types) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   if (!append)
     types.Clear();
 
-  if (context.empty())
+  if (pattern.empty())
     return 0;
 
-  ConstString name = context.back().name;
+  ConstString name = pattern.back().name;
 
   if (!name)
     return 0;
 
   DIEArray die_offsets;
   m_index->GetTypes(name, die_offsets);
   const size_t num_die_matches = die_offsets.size();
 
   size_t num_matches = 0;
   for (size_t i = 0; i < num_die_matches; ++i) {
     const DIERef &die_ref = die_offsets[i];
     DWARFDIE die = GetDIE(die_ref);
 
     if (die) {
-      std::vector<CompilerContext> die_context;
+      llvm::SmallVector<CompilerContext, 4> die_context;
       die.GetDeclContext(die_context);
-      if (die_context != context)
+      if (!contextMatches(die_context, pattern))
         continue;
 
       Type *matching_type = ResolveType(die, true, true);
       if (matching_type) {
         // We found a type pointer, now find the shared pointer form our type
         // list
         types.InsertUnique(matching_type->shared_from_this());
         ++num_matches;

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

uint32_t FindFunctions(const RegularExpression &regex, bool include_inlines,
                          bool append, SymbolContextList &sc_list) override;
 
   uint32_t FindTypes(ConstString name,
                      const CompilerDeclContext *parent_decl_ctx, bool append,
                      uint32_t max_matches,
                      llvm::DenseSet<SymbolFile *> &searched_symbol_files,
                      TypeMap &types) override;
 
-  size_t FindTypes(const std::vector<CompilerContext> &context, bool append,
+  size_t FindTypes(llvm::ArrayRef<CompilerContext> pattern, bool append,
                    TypeMap &types) override;
 
   llvm::Expected<TypeSystem &>
   GetTypeSystemForLanguage(lldb::LanguageType language) override;
 
   CompilerDeclContext
   FindNamespace(ConstString name,
                 const CompilerDeclContext *parent_decl_ctx) override;

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

uint32_t SymbolFileNativePDB::FindTypes(
   searched_symbol_files.insert(this);
 
   // There is an assumption 'name' is not a regex
   size_t match_count = FindTypesByName(name.GetStringRef(), max_matches, types);
 
   return match_count;
 }
 
-size_t
-SymbolFileNativePDB::FindTypes(const std::vector<CompilerContext> &context,
+size_t SymbolFileNativePDB::FindTypes(llvm::ArrayRef<CompilerContext> pattern,
                                       bool append, TypeMap &types) {
   return 0;
 }
 
 size_t SymbolFileNativePDB::FindTypesByName(llvm::StringRef name,
                                             uint32_t max_matches,
                                             TypeMap &types) {
 
   size_t match_count = 0;

lldb/trunk/source/Plugins/SymbolFile/PDB/SymbolFilePDB.h

public:
 
   uint32_t
   FindTypes(lldb_private::ConstString name,
             const lldb_private::CompilerDeclContext *parent_decl_ctx,
             bool append, uint32_t max_matches,
             llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
             lldb_private::TypeMap &types) override;
 
-  size_t FindTypes(const std::vector<lldb_private::CompilerContext> &context,
+  size_t FindTypes(llvm::ArrayRef<lldb_private::CompilerContext> pattern,
                    bool append, lldb_private::TypeMap &types) override;
 
   void FindTypesByRegex(const lldb_private::RegularExpression &regex,
                         uint32_t max_matches, lldb_private::TypeMap &types);
 
   size_t GetTypes(lldb_private::SymbolContextScope *sc_scope,
                   lldb::TypeClass type_mask,
                   lldb_private::TypeList &type_list) override;

lldb/trunk/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp

while (auto result = results->getNext()) {
     auto iter = m_types.find(result->getSymIndexId());
     if (iter == m_types.end())
       continue;
     types.Insert(iter->second);
     ++matches;
   }
 }
 
-size_t SymbolFilePDB::FindTypes(
-    const std::vector<lldb_private::CompilerContext> &contexts, bool append,
-    lldb_private::TypeMap &types) {
+size_t SymbolFilePDB::FindTypes(llvm::ArrayRef<CompilerContext> pattern,
+                                bool append, lldb_private::TypeMap &types) {
   return 0;
 }
 
 void SymbolFilePDB::GetTypesForPDBSymbol(const llvm::pdb::PDBSymbol &pdb_symbol,
                                          uint32_t type_mask,
                                          TypeCollection &type_collection) {
   bool can_parse = false;
   switch (pdb_symbol.getSymTag()) {

lldb/trunk/source/Symbol/SymbolFile.cpp

uint32_t SymbolFile::FindTypes(
     bool append, uint32_t max_matches,
     llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
     TypeMap &types) {
   if (!append)
     types.Clear();
   return 0;
 }
 
-size_t SymbolFile::FindTypes(const std::vector<CompilerContext> &context,
+size_t SymbolFile::FindTypes(llvm::ArrayRef<CompilerContext> pattern,
                              bool append, TypeMap &types) {
   if (!append)
     types.Clear();
   return 0;
 }
 
 void SymbolFile::AssertModuleLock() {
   // The code below is too expensive to leave enabled in release builds. It's

lldb/trunk/source/Symbol/Type.cpp

 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 
 #include "llvm/ADT/StringRef.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
+bool lldb_private::contextMatches(llvm::ArrayRef<CompilerContext> context_chain,
+                                  llvm::ArrayRef<CompilerContext> pattern) {
+  auto ctx = context_chain.begin();
+  auto ctx_end = context_chain.end();
+  for (const CompilerContext &pat : pattern) {
+    // Early exit if the pattern is too long.
+    if (ctx == ctx_end)
+      return false;
+    if (*ctx != pat) {
+      // Skip any number of module matches.
+      if (pat.kind == CompilerContextKind::AnyModule) {
+        // Greedily match 0..n modules.
+        ctx = std::find_if(ctx, ctx_end, [](const CompilerContext &ctx) {
+          return ctx.kind != CompilerContextKind::Module;
+        });
+        continue;
+      }
+      // See if there is a kind mismatch; they should have 1 bit in common.
+      if (((uint16_t)ctx->kind & (uint16_t)pat.kind) == 0)
+        return false;
+      // The name is ignored for AnyModule, but not for AnyType.
+      if (pat.kind != CompilerContextKind::AnyModule && ctx->name != pat.name)
+        return false;
+    }
+    ++ctx;
+  }
+  return true;
+}
+
 void CompilerContext::Dump() const {
-  switch (type) {
-  case CompilerContextKind::Invalid:
+  switch (kind) {
+  default:
     printf("Invalid");
     break;
   case CompilerContextKind::TranslationUnit:
     printf("TranslationUnit");
     break;
   case CompilerContextKind::Module:
     printf("Module");
     break;
   case CompilerContextKind::Namespace:
     printf("Namespace");
     break;
   case CompilerContextKind::Class:
     printf("Class");
     break;
-  case CompilerContextKind::Structure:
+  case CompilerContextKind::Struct:
     printf("Structure");
     break;
   case CompilerContextKind::Union:
     printf("Union");
     break;
   case CompilerContextKind::Function:
     printf("Function");
     break;
   case CompilerContextKind::Variable:
     printf("Variable");
     break;
-  case CompilerContextKind::Enumeration:
+  case CompilerContextKind::Enum:
     printf("Enumeration");
     break;
   case CompilerContextKind::Typedef:
     printf("Typedef");
     break;
+  case CompilerContextKind::AnyModule:
+    printf("AnyModule");
+    break;
+  case CompilerContextKind::AnyType:
+    printf("AnyType");
+    break;
   }
   printf("(\"%s\")\n", name.GetCString());
 }
 
 class TypeAppendVisitor {
 public:
   TypeAppendVisitor(TypeListImpl &type_list) : m_type_list(type_list) {}
 

lldb/trunk/tools/lldb-test/lldb-test.cpp

for (auto entry_str : entries_str) {
     StringRef key, value;
     std::tie(key, value) = entry_str.split(':');
     auto kind =
         StringSwitch<CompilerContextKind>(key)
             .Case("TranslationUnit", CompilerContextKind::TranslationUnit)
             .Case("Module", CompilerContextKind::Module)
             .Case("Namespace", CompilerContextKind::Namespace)
             .Case("Class", CompilerContextKind::Class)
-            .Case("Structure", CompilerContextKind::Structure)
+            .Case("Struct", CompilerContextKind::Struct)
             .Case("Union", CompilerContextKind::Union)
             .Case("Function", CompilerContextKind::Function)
             .Case("Variable", CompilerContextKind::Variable)
-            .Case("Enumeration", CompilerContextKind::Enumeration)
+            .Case("Enum", CompilerContextKind::Enum)
             .Case("Typedef", CompilerContextKind::Typedef)
+            .Case("AnyModule", CompilerContextKind::AnyModule)
+            .Case("AnyType", CompilerContextKind::AnyType)
             .Default(CompilerContextKind::Invalid);
     if (value.empty()) {
       WithColor::error() << "compiler context entry has no \"name\"\n";
       exit(1);
     }
     result.push_back({kind, ConstString{value}});
   }
   outs() << "Search context: {\n";
CompilerDeclContext *ContextPtr =
       ContextOr->IsValid() ? &*ContextOr : nullptr;
 
   DenseSet<SymbolFile *> SearchedFiles;
   TypeMap Map;
   if (!Name.empty())
     Symfile.FindTypes(ConstString(Name), ContextPtr, true, UINT32_MAX,
                       SearchedFiles, Map);
   else
-    Symfile.FindTypes(parseCompilerContext(), true, Map);
+    Symfile.FindTypes({parseCompilerContext()}, true, Map);
 
   outs() << formatv("Found {0} types:\n", Map.GetSize());
   StreamString Stream;
   Map.Dump(&Stream, false);
   outs() << Stream.GetData() << "\n";
   return Error::success();
 }
 

lldb/trunk/unittests/Symbol/TestType.cpp

TestGetTypeScopeAndBasenameHelper("std::set<int>::iterator", true,
                                     "std::set<int>::", "iterator");
   TestGetTypeScopeAndBasenameHelper(
       "std::set<int, std::less<int>>::iterator", true,
       "std::set<int, std::less<int>>::", "iterator");
   TestGetTypeScopeAndBasenameHelper(
       "std::set<int, std::less<int>>::iterator<bool>", true,
       "std::set<int, std::less<int>>::", "iterator<bool>");
 }
+
+TEST(Type, CompilerContextPattern) {
+  std::vector<CompilerContext> mms = {
+      {CompilerContextKind::Module, ConstString("A")},
+      {CompilerContextKind::Module, ConstString("B")},
+      {CompilerContextKind::Struct, ConstString("S")}};
+  EXPECT_TRUE(contextMatches(mms, mms));
+  std::vector<CompilerContext> mmc = {
+      {CompilerContextKind::Module, ConstString("A")},
+      {CompilerContextKind::Module, ConstString("B")},
+      {CompilerContextKind::Class, ConstString("S")}};
+  EXPECT_FALSE(contextMatches(mms, mmc));
+  std::vector<CompilerContext> ms = {
+      {CompilerContextKind::Module, ConstString("A")},
+      {CompilerContextKind::Struct, ConstString("S")}};
+  std::vector<CompilerContext> mas = {
+      {CompilerContextKind::Module, ConstString("A")},
+      {CompilerContextKind::AnyModule, ConstString("*")},
+      {CompilerContextKind::Struct, ConstString("S")}};
+  EXPECT_TRUE(contextMatches(mms, mas));
+  EXPECT_TRUE(contextMatches(ms, mas));
+  EXPECT_FALSE(contextMatches(mas, ms));
+  std::vector<CompilerContext> mmms = {
+      {CompilerContextKind::Module, ConstString("A")},
+      {CompilerContextKind::Module, ConstString("B")},
+      {CompilerContextKind::Module, ConstString("C")},
+      {CompilerContextKind::Struct, ConstString("S")}};
+  EXPECT_TRUE(contextMatches(mmms, mas));
+  std::vector<CompilerContext> mme = {
+      {CompilerContextKind::Module, ConstString("A")},
+      {CompilerContextKind::Module, ConstString("B")},
+      {CompilerContextKind::Enum, ConstString("S")}};
+  std::vector<CompilerContext> mma = {
+      {CompilerContextKind::Module, ConstString("A")},
+      {CompilerContextKind::Module, ConstString("B")},
+      {CompilerContextKind::AnyType, ConstString("S")}};
+  EXPECT_TRUE(contextMatches(mme, mma));
+  EXPECT_TRUE(contextMatches(mms, mma));
+  std::vector<CompilerContext> mme2 = {
+      {CompilerContextKind::Module, ConstString("A")},
+      {CompilerContextKind::Module, ConstString("B")},
+      {CompilerContextKind::Enum, ConstString("S2")}};
+  EXPECT_FALSE(contextMatches(mme2, mma));
+}