Give the SymbolFile plugin enough information to efficiently do exact match lookups

[zturner]

Summary

Previously the Module would parse a type name into scope and base name during a lookup and only give the SymbolFile plugin the base name, then it would filter the results down into the match set based on whether it was supposed to be an exact match.

However, if this is supposed to be an exact match, a SymbolFile can do this lookup in O(1) time by using its internal accelerator tables, but it can't do this unless it actually receives the full name as well as the information that it is supposed to be an exact match. Rather than being too smart, we should just let the symbol file plugin be the arbiter to decide how it wants to do lookups, so we should pass it the full name.

I'm trying to keep this as NFC for the DWARF plugin, so I took the code that was in Module.cpp and tried to rewrite it to be equivalent at the top of SymbolFileDWARF::FindTypes

[zturner]

Note that AFAICT, native PDB plugin is now the only plugin where you can do type lookup -- NS::Struct::Local and have it return instantly. On the regular PDB plugin it doesn't work at all (returns no results). On the DWARF plugin, I haven't tested, but it will either not work at all, or take a potentially long time if you have a lot of debug info).

[jingham]

I worry that your patch changes the behavior when you add the type_class explicitly in the lookup (i.e. look up "struct Struct" not "Struct". That should work...

Note, this doesn't currently work in type lookup:

(lldb) type lookup "struct Foo"
no type was found matching '"struct Foo"'

which I'll have to fix (grr...), but does work correctly in the SB API's:

(lldb) script
Python Interactive Interpreter. To exit, type 'quit()', 'exit()' or Ctrl-D.
>>> module = lldb.target.modules[0]
>>> print module
(x86_64) /tmp/structs
>>> result_list = module.FindTypes("struct Foo")
>>> print result_list.GetSize()
1
>>> print result_list.GetTypeAtIndex(0)
struct Foo {
    int First;
}

Other than that this looks correct to me.

lldb/source/Core/Module.cpp

1038

GetTypeScopeAndBasename's behavior is not well documented. It has a bool return which should mean some kind of failure. The code you are replacing checks for type_basename.empty() and the type_class not being set, and falls back on the input name if it is. You unconditionally use type_basename.

The old code's test doesn't actually accord with the current behavior of GetTypeScopeAndBasename, which will only leave basename empty if the input name was empty, so far as I can see. So I don't think your version is wrong, but it is right only by accident. If we are going to rely on this behavior then it's probably a good idea to document it in the definition of GetTypeScopeAndBasename. Or go back to checking whether type_basename is empty...

Also, by not calling GetTypeScopeAndBasename before you call FindTypes_Impl, your version of the code would pass it "struct Foo" if that's what the user typed, whereas the old code would pass "Foo" (the struct would get stripped by GetTypeScopeAndBasename). I'm not sure whether that matters, did you try 'type lookup "struct Struct"' or something like that? It doesn't look like you do that in your test cases.

Also your "exact" would call "struct ::Foo" not exact, whereas the old code would call that exact.

[zturner]

In D53662#1275238, @jingham wrote:

I worry that your patch changes the behavior when you add the type_class explicitly in the lookup (i.e. look up "struct Struct" not "Struct". That should work...

Note, this doesn't currently work in type lookup:

(lldb) type lookup "struct Foo"
no type was found matching '"struct Foo"'

Ahh, nice catch. Luckily it should be easy to add a couple of tests for those alongside the other ones I added, so I'll try that and upload a new version.

[zturner]

Fixed issues pointed out by @jingham and added some test coverage for this.

[jingham]

This looks good to me.

Looking at the addition of Type::ConsumeTypeClass makes it really clear that both this function and Type::GetTypeScopeAndBasename need to dispatch to the CompilerSystem to do this work. The actual code is way too C-family-ish to be in the generic Type.cpp. That will require passing in a language because I don't think you know enough from just the symfile and name to know which language the user was looking up types for.

But this change doesn't make it harder to get that right, so fixing it doesn't need to be part of this patch.

So far as I can tell, you can't do an O(1) lookup of an exact name in DWARF from the dwarf_names table (or the proceeding apple tables). The tables are organized by base name (or really whatever in the DW_AT_name attribute of the die). So you will always have to pull the base name out, find all the base name matches and then run up the parent dies to build up the fully qualified name. Each name entry has the parent DIE, so building up the full name is pretty efficient. But still, the best you can do O(number_of_occurances_of_name) and knowing the name is exact doesn't help the search speed. If I'm right about that (Greg will surely know) then we should remove the FIXME comment in SymbolFileDWARF since it refers to an unfixable fix.

[clayborg]

The current SymbolFile::FindTypes(...) in was designed with type base name only due to how DWARF stores it type information. It has a "const CompilerDeclContext *parent_decl_ctx" which can be specified in order to limit what we find. So we might be able to think of this as a type lookup by basename. It might be handy to add another type lookup that does lookups by fully qualified name only. and leave the current infrastructure alone? A default implementation can be added that returns false for all symbol file unless they support name lookup.

The current implementation allows you to under specify a type. For code like:

struct Pt { char x; char y; };
namespace a {
  struct Pt { short x; short y; };
  namespace b {
    struct Pt { int x; int y; };
  }
}

We can find all of them using:

(lldb) type lookup Pt
struct Pt {
    short x;
    short y;
}
struct Pt {
    int x;
    int y;
}
struct Pt {
    char x;
    char y;
}

Or each one individually using:

(lldb) type lookup a::b::Pt
struct Pt {
    int x;
    int y;
}
(lldb) type lookup a::Pt
struct Pt {
    short x;
    short y;
}
(lldb) type lookup ::Pt
struct Pt {
    char x;
    char y;
}

Or under specify the namespace:

(lldb) type lookup b::Pt
struct Pt {
    int x;
    int y;
}

That is the current behavior. Not saying it is right. Note we also don't display the decl context for a type when dumping it which would be nice to fix. So we probably need to make sure there are tests for all of the cases above once we hone in on the approach we want all symbol plug-ins to use.

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

2443

There is no O(1) lookup for types in DWARF. Accelerator tables do not have fully qualified type names, only the identifier for the type basename only.

[jingham]

So the current approach relies on the ability to sniff the name to determine the context in which the user intends to find it. It does (and always did) use the presence of an initial "::" to tell whether a symbol is exact. That's obviously also inappropriate for a generic Type method. But OTOH, there needs to be a funnel point where you take in a string you know nothing about (from the user either in type lookup or in an expression) and find it as best you can. I don't think we want to force command line users to say "type lookup --exact " so we've got to figure it out internally.

Internally, it might be helpful to do some initial analysis of the input type string, and then dispatch it to an exact or inexact search. But given I don't think you can get away without a FindTypes that takes a string that you don't know whether it is exact or not, I don't feel strongly about that.

We should abstract "is exact" and ask the various type systems to handle that request, and we also need to abstract "remove type class" and again ask the various type systems to handle that. That seems to me the main ugliness that this patch reveals.

[zturner]

In D53662#1276253, @jingham wrote:

So the current approach relies on the ability to sniff the name to determine the context in which the user intends to find it. It does (and always did) use the presence of an initial "::" to tell whether a symbol is exact. That's obviously also inappropriate for a generic Type method. But OTOH, there needs to be a funnel point where you take in a string you know nothing about (from the user either in type lookup or in an expression) and find it as best you can. I don't think we want to force command line users to say "type lookup --exact " so we've got to figure it out internally.

Internally, it might be helpful to do some initial analysis of the input type string, and then dispatch it to an exact or inexact search. But given I don't think you can get away without a FindTypes that takes a string that you don't know whether it is exact or not, I don't feel strongly about that.

We should abstract "is exact" and ask the various type systems to handle that request, and we also need to abstract "remove type class" and again ask the various type systems to handle that. That seems to me the main ugliness that this patch reveals.

Just to clarify, is the consensus then that I can submit this as is? Or that it needs some modification? Greg's suggestion of making a separate method called FindExactType could work, but it doesn't seem that much different than passing a boolean call exact_match, which is what I've done here. On the extreme end, we could just make Module::FindTypes do absolutely nothing except call the SymbolFile plugin. I don't feel too strongly either way. The current patch seems NFC for DWARF and strictly better for PDB, but I'm willing to make changes if anyone feels like there's an architecturally more sound approach.

[jingham]

It seemed to me like Greg thought you were changing the behavior of lookups, which this patch doesn't do, it just makes it more efficient. I don't know if that alters his objections or not.

The Module and higher layer of FindTypes calls are awkward. For instance Module::FindTypes takes an "exact_match" parameter, but it doesn't actually mean "exact match". If exact_match is passed in as true, then it does mean exactly match the name. But if it is false it means "check if this name is fully qualified and if so make it an exact match otherwise do a partial match".

The header comment for the function is wrong, too. It says:

/// @param[in] exact_match
///     If \b true, \a type_name is fully qualified and must match
///     exactly. If \b false, \a type_name is a partially qualified
///     name where the leading namespaces or classes can be
///     omitted to make finding types that a user may type
///     easier.

So we should change the variable name (or even just the docs) at this level to better reflect what the parameter actually does. You still need to turn off the guessing because we don't have a 100% certain way to tell whether a type name is fully qualified, and the alternative of prepending a "::" to force the guessing algorithm's hand is gross (and very C++ specific). But with that proviso, I don't think passing this as a parameter is any better/worse than having Module:FindTypesExact and Module::FindTypesAutoDetect or some better name that I can't think up right now.

But I don't think the logical third option: "FindTypesPartial" that forces a partial match is useful. I can't see anybody typing "::foo" and wanting that to match "bar::foo". So expressing this as a bool parameter seems fine to me.

OTOH, I don't think it is desirable to have different versions of the Symfile and lower calls for Exact and not Exact, passing the exact_match parameter through there is fine IMO. After all, in all these calls exact_match means exactly what it says, you are requiring an exact match. So you don't gain clarity by having different function names.

BTW, you should remove the O(1) FIXME comment so you don't send some future eager contributor on a wild goose chase to figure out how to do this thing you can't do in DWARF.

[clayborg]

My issue with adding "exact_match" is it renders a few of the arguments useless:

size_t FindTypes(
  const SymbolContext &sc, 
  llvm::StringRef name,
  const CompilerDeclContext *parent_decl_ctx, 
  bool exact_match,
  ...);

With exact_match "parent_decl_ctx" is useless and possible the symbol context too. The FindTypes as written today was used for two cases which evolved over time:

• finding types for users without needing to be fully qualified
• finding types for the expression parser in a specific context

To fulfill these two cases, arguments have been added over time. As we keep adding arguments we make the function even harder to implement for SymbolFile subclasses. So as long as we are cleaning things up, it might be time to factor this out by making changes now.

Another complexity is that we can either search a single module or multiple modules when doing searches, and that is why we have Module::FindTypes_Impl(...) in since there is some work that needs to be done when we are searching by basename only (strip the context and search by basename, then filters matches afterward.

That is why I was thinking we might want to make changes. Seems like having:

size_t FindTypesByBasename(
  const SymbolContext &sc, 
  llvm::StringRef name,
  const CompilerDeclContext *parent_decl_ctx
  ...);

size_t FindTypesByFullname(llvm::StringRef name, ...);

Clients of the first call must strip a typename to its identifier name prior to calling, and clients of the second can call with a fully qualified typename.

[zturner]

Ok, that reasoning makes sense, I’ll see what i can do

[zturner]

So I started looking into this, and things get tricky. If we're doing a lookup by fully qualified name, I would expect there to never be more than one match, but LLDB doesn't seem to hold this same assumption. For example, in ItaniumABILanguageRuntime::GetTypeInfoFromVTableAddress there is code that tries to get an exact match from a single module, and if it doesn't find one, then searches the entire module list for multiple matches on exact name, then specifically handles the case where more than one match was found. Most of this code is all just for the purposes of logging, but if we cut through all the logging and just get down to the code, it basically amounts to this:

  type_info.SetName(class_name);
  TypeList class_types;

  uint32_t num_matches = 0;
  // First look in the module that the vtable symbol came from and
  // look for a single exact match.
  llvm::DenseSet<SymbolFile *> searched_symbol_files;
  if (sc.module_sp) {
    num_modules = sc.module_sp->FindTypes(sc, ConstString(lookup_name),
      exact_match, 1, searched_symbol_files, class_types);
  }

  // If we didn't find a symbol, then move on to the entire module
  // list in the target and get as many unique matches as possible
  if (num_matches == 0) {
    num_matches = target.GetImages().FindTypes(
        sc, ConstString(lookup_name), exact_match, UINT32_MAX,
        searched_symbol_files, class_types);
  }

  lldb::TypeSP type_sp;
  if (num_matches == 0)
    return TypeAndOrName();
  if (num_matches == 1) {
    type_sp = class_types.GetTypeAtIndex(0);
    if (type_sp) {
      if (ClangASTContext::IsCXXClassType(
              type_sp->GetForwardCompilerType())) {
        type_info.SetTypeSP(type_sp);
    }
  } else if (num_matches > 1) {
    size_t i;

    for (i = 0; i < num_matches; i++) {
      type_sp = class_types.GetTypeAtIndex(i);
      if (type_sp) {
        if (ClangASTContext::IsCXXClassType(
                type_sp->GetForwardCompilerType())) {
          type_info.SetTypeSP(type_sp);
        }
      }
    }

  }
  if (type_info)
    SetDynamicTypeInfo(vtable_addr, type_info);
  return type_info;
}

Why would we ever get more than one type on a fully qualifed exact match name lookup? And even if we did, why would we care which one we chose?

[jingham]

Exact matches aren't a C++ specific thing. An exact match is useful for mixed C/C++ since you might want to say Foo and not Bar::Foo. IIRC a couple of the places where exact was dialed up explicitly in FindTypes were for C types. But since C and ObjC allow multiple types with the same name, that's one way you might see multiple matches for "exact match". Moreover C+ used to be fuzzy about whether non-exported classes from different linkage uses had to follow the ODR. I haven't followed whether this got nailed down but it still seems Quixotic to expect you could enforce this, since you are asking two totally unrelated library vendors to avoid each other's names for private classes... So having several classes with the same name is still a possibility IRL with C++.

Why we care is that if somebody runs the command:

(lldb) expression (::SomeClass *) 0x12345

We're going to try our best to make that work. If SomeClass is not visible in the module/comp_unit/function in which we are currently stopped, then we will go looking far and wide for SomeClass. If we find one result somewhere out in the world, the expression will succeed, but if we find two results which are different, then we want to give an error about ambiguous type.

[zturner]

In D53662#1279738, @jingham wrote:

Exact matches aren't a C++ specific thing. An exact match is useful for mixed C/C++ since you might want to say Foo and not Bar::Foo. IIRC a couple of the places where exact was dialed up explicitly in FindTypes were for C types. But since C and ObjC allow multiple types with the same name, that's one way you might see multiple matches for "exact match". Moreover C+ used to be fuzzy about whether non-exported classes from different linkage uses had to follow the ODR. I haven't followed whether this got nailed down but it still seems Quixotic to expect you could enforce this, since you are asking two totally unrelated library vendors to avoid each other's names for private classes... So having several classes with the same name is still a possibility IRL with C++.

Why we care is that if somebody runs the command:

(lldb) expression (::SomeClass *) 0x12345

We're going to try our best to make that work. If SomeClass is not visible in the module/comp_unit/function in which we are currently stopped, then we will go looking far and wide for SomeClass. If we find one result somewhere out in the world, the expression will succeed, but if we find two results which are different, then we want to give an error about ambiguous type.

So when designing this new FindTypesByFullyQualifiedName API, is it safe to assume, for the purposes of the API signature, that at the Module level, it will either return 0 or 1 match (e.g. the return value shoudl be a TypeSP, but at the ModuleList level, it can return arbitrarily many (so the return value should be a TypeList?

[jingham]

That depends on the definition of "fully qualified name". If you can ensure that it means "name of C++ class" - or other ODR enforcing type system, then you could make that assumption. In C you are free to redefine types on a per-function basis if you so desire; and sadly some interface generators (including MIG the one for generating Mach message handlers) do just this...) So you would need to see a way to restrict the inputs to this function. That doesn't seem like it would be straightforward to me.

[jingham]

You could also get multiple matches if you had classes in anonymous namespaces with the same name in multiple compile units.

[zturner]

In D53662#1279761, @jingham wrote:

That depends on the definition of "fully qualified name". If you can ensure that it means "name of C++ class" - or other ODR enforcing type system, then you could make that assumption. In C you are free to redefine types on a per-function basis if you so desire; and sadly some interface generators (including MIG the one for generating Mach message handlers) do just this...) So you would need to see a way to restrict the inputs to this function. That doesn't seem like it would be straightforward to me.

After I've changed up the codebase there is only one usage of it that I'm not sure is used in an ODR-enforcing context, which is ObjCLanguageRuntime::LookupInCompleteClassCache. All other usages are C++ or Java specific. Anyway, I guess I'll do it that way for now and upload the patch. This already turned out to be more invasvive than I was hoping for, so if this doesn't work out or someone doesn't like the approach, maybe I can just go back to the original patch and submit that

[jingham]

Yes, that usage is exactly the sort of use I was talking about. When we get an ObjC object and want to find its dynamic type, we read the type name by following the object's ISA pointer to the Class object. Then we go to look up the type from that name. We know we want an exact match to the name we found, but there's nothing that says the same module can't have an C++ class with the same name as an ObjC class. So that code needs to get all the types found, and sort through them for the one that is an ObjC interface type, and discard all the others. You will need to support that behavior somehow.

[zturner]

In D53662#1279777, @jingham wrote:

Yes, that usage is exactly the sort of use I was talking about. When we get an ObjC object and want to find its dynamic type, we read the type name by following the object's ISA pointer to the Class object. Then we go to look up the type from that name. We know we want an exact match to the name we found, but there's nothing that says the same module can't have an C++ class with the same name as an ObjC class. So that code needs to get all the types found, and sort through them for the one that is an ObjC interface type, and discard all the others. You will need to support that behavior somehow.

So just to make sure I understand, The C++ and ObjC classes are both potentially in the same Module, both potentially with the same name, correct?

[jingham]

Yes. You can't put them in the same CompileUnit because declaring variables of the type would be ambiguous (though all other references would be okay since ObjC method dispatch looks totally different from C++ method calling). But there's nothing keeping the same module from having a C++ and an ObjC class of the same name.

lldb/include/lldb/Core/Module.h

protected:
   friend class ModuleList;
   friend class ObjectFile;
   friend class SymbolFile;
 
 private:
   Module(); // Only used internally by CreateJITModule ()
 
   size_t FindTypes_Impl(
-      const SymbolContext &sc, const ConstString &name,
-      const CompilerDeclContext *parent_decl_ctx, bool append,
+      const SymbolContext &sc, llvm::StringRef name,
+      const CompilerDeclContext *parent_decl_ctx, bool exact_match, bool append,
       size_t max_matches,
       llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
       TypeMap &types);
 
   DISALLOW_COPY_AND_ASSIGN(Module);
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_Module_h_

lldb/include/lldb/Symbol/SymbolFile.h

virtual uint32_t FindFunctions(const ConstString &name,
                                  const CompilerDeclContext *parent_decl_ctx,
                                  lldb::FunctionNameType name_type_mask,
                                  bool include_inlines, bool append,
                                  SymbolContextList &sc_list);
   virtual uint32_t FindFunctions(const RegularExpression &regex,
                                  bool include_inlines, bool append,
                                  SymbolContextList &sc_list);
   virtual uint32_t
-  FindTypes(const SymbolContext &sc, const ConstString &name,
-            const CompilerDeclContext *parent_decl_ctx, bool append,
-            uint32_t max_matches,
+  FindTypes(const SymbolContext &sc, llvm::StringRef name,
+            const CompilerDeclContext *parent_decl_ctx, bool exact_match,
+            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 void
   GetMangledNamesForFunction(const std::string &scope_qualified_name,
                              std::vector<ConstString> &mangled_names);

lldb/include/lldb/Symbol/SymbolVendor.h

virtual size_t FindFunctions(const ConstString &name,
                                bool include_inlines, bool append,
                                SymbolContextList &sc_list);
 
   virtual size_t FindFunctions(const RegularExpression &regex,
                                bool include_inlines, bool append,
                                SymbolContextList &sc_list);
 
   virtual size_t
-  FindTypes(const SymbolContext &sc, const ConstString &name,
-            const CompilerDeclContext *parent_decl_ctx, bool append,
-            size_t max_matches,
+  FindTypes(const SymbolContext &sc, llvm::StringRef name,
+            const CompilerDeclContext *parent_decl_ctx, bool exact_match,
+            bool append, size_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 CompilerDeclContext
   FindNamespace(const SymbolContext &sc, const ConstString &name,

lldb/include/lldb/Symbol/Type.h

public:
   CompilerType GetLayoutCompilerType();
 
   // Get the clang type and leave class/struct/union/enum types as forward
   // declarations if they haven't already been fully defined.
   CompilerType GetForwardCompilerType();
 
   static int Compare(const Type &a, const Type &b);
 
+  static lldb::TypeClass ConsumeTypeClass(llvm::StringRef &name);
+
   // From a fully qualified typename, split the type into the type basename and
   // the remaining type scope (namespaces/classes).
-  static bool GetTypeScopeAndBasename(const llvm::StringRef& name,
+  static bool GetTypeScopeAndBasename(const llvm::StringRef &name,
                                       llvm::StringRef &scope,
-                                      llvm::StringRef &basename,
-                                      lldb::TypeClass &type_class);
+                                      llvm::StringRef &basename);
   void SetEncodingType(Type *encoding_type) { m_encoding_type = encoding_type; }
 
   uint32_t GetEncodingMask();
 
   bool IsCompleteObjCClass() { return m_flags.is_complete_objc_class; }
 
   void SetIsCompleteObjCClass(bool is_complete_objc_class) {
     m_flags.is_complete_objc_class = is_complete_objc_class;

lldb/include/lldb/Symbol/TypeMap.h

public:
 
   void ForEach(
       std::function<bool(const lldb::TypeSP &type_sp)> const &callback) const;
 
   void ForEach(std::function<bool(lldb::TypeSP &type_sp)> const &callback);
 
   bool Remove(const lldb::TypeSP &type_sp);
 
+  void OnlyKeepTypeClass(lldb::TypeClass type_class);
+
   void RemoveMismatchedTypes(const char *qualified_typename, bool exact_match);
 
   void RemoveMismatchedTypes(const std::string &type_scope,
                              const std::string &type_basename,
                              lldb::TypeClass type_class, bool exact_match);
 
   void RemoveMismatchedTypes(lldb::TypeClass type_class);
 

lldb/lit/SymbolFile/NativePDB/Inputs/tag-types.lldbinit

 type lookup -- Struct
 type lookup -- Class
 type lookup -- Union
 type lookup -- Derived
 type lookup -- Derived2
 type lookup -- EnumInt
 type lookup -- EnumShort
+type lookup -- NS::Struct
+type lookup -- NS::Struct::Local
 type lookup -- InvalidType
+
+type lookup -- struct Struct
+type lookup -- class Class
+type lookup -- union Union
+type lookup -- enum EnumInt
+
+type lookup -- ::Struct
+type lookup -- struct ::Struct
+
+type lookup -- class Struct
+type lookup -- class ::Struct
 No newline at end of file

lldb/lit/SymbolFile/NativePDB/tag-types.cpp

 };
 
 // Test explicit underlying types
 enum EnumShort : short {
   ES_A = 2,
   ES_B = 3
 };
 
+namespace NS {
+  struct Struct {
+    int X;
+    struct Local {
+      int Y;
+    };
+  };
+}
+
 int main(int argc, char **argv) {
   Struct S;
   Class C;
   Union U;
   Derived D;
   Derived2 D2;
   EnumInt EI;
   EnumShort ES;
+  NS::Struct NSS;
+  NS::Struct::Local NSSL;
   
   return 0;
 }
 
 // CHECK:      (lldb) target create "{{.*}}tag-types.cpp.tmp.exe"
 // CHECK-NEXT: Current executable set to '{{.*}}tag-types.cpp.tmp.exe' (x86_64).
 // CHECK-NEXT: (lldb) command source -s 0 '{{.*}}tag-types.lldbinit'
 // CHECK-NEXT: Executing commands in '{{.*}}tag-types.lldbinit'.

 // CHECK-NEXT:     A,
 // CHECK-NEXT:     B
 // CHECK-NEXT: }
 // CHECK-NEXT: (lldb) type lookup -- EnumShort
 // CHECK-NEXT: enum EnumShort {
 // CHECK-NEXT:     ES_A,
 // CHECK-NEXT:     ES_B
 // CHECK-NEXT: }
+// CHECK-NEXT: (lldb) type lookup -- NS::Struct
+// CHECK-NEXT: struct NS::Struct {
+// CHECK-NEXT:   int X;
+// CHECK-NEXT: }
+// CHECK-NEXT: (lldb) type lookup -- NS::Struct::Local
+// CHECK-NEXT: struct NS::Struct::Local {
+// CHECK-NEXT:   int Y;
+// CHECK-NEXT: }
 // CHECK-NEXT: (lldb) type lookup -- InvalidType
 // CHECK-NEXT: no type was found matching 'InvalidType'
+
+// CHECK-NEXT: (lldb) type lookup -- struct Struct
+// CHECK-NEXT: struct Struct {
+
+// CHECK:      (lldb) type lookup -- class Class
+// CHECK-NEXT: class Class {
+
+// CHECK:      (lldb) type lookup -- union Union
+// CHECK-NEXT: union Union {
+
+// CHECK:      (lldb) type lookup -- enum EnumInt
+// CHECK-NEXT: enum EnumInt {
+
+// CHECK:      (lldb) type lookup -- ::Struct
+// CHECK-NEXT: struct Struct {
+
+// CHECK:      (lldb) type lookup -- struct ::Struct
+// CHECK-NEXT: struct Struct {
+
+// CHECK:      (lldb) type lookup -- class Struct
+// CHECK-NEXT: no type was found matching 'class Struct'
+
+// CHECK:      (lldb) type lookup -- class ::Struct
+// CHECK-NEXT: no type was found matching 'class ::Struct'

lldb/source/Core/Module.cpp

for (size_t n = 0; n < resolver.GetNumberOfAddresses(); n++) {
     if (f && f == function)
       output_local.push_back(addr);
     else
       output_extern.push_back(addr);
   }
 }
 
 size_t Module::FindTypes_Impl(
-    const SymbolContext &sc, const ConstString &name,
-    const CompilerDeclContext *parent_decl_ctx, bool append, size_t max_matches,
+    const SymbolContext &sc, llvm::StringRef name,
+    const CompilerDeclContext *parent_decl_ctx, bool exact_match, bool append,
+    size_t max_matches,
     llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
     TypeMap &types) {
   static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
   Timer scoped_timer(func_cat, LLVM_PRETTY_FUNCTION);
   if (!sc.module_sp || sc.module_sp.get() == this) {
     SymbolVendor *symbols = GetSymbolVendor();
     if (symbols)
-      return symbols->FindTypes(sc, name, parent_decl_ctx, append, max_matches,
-                                searched_symbol_files, types);
+      return symbols->FindTypes(sc, name, parent_decl_ctx, exact_match, append,
+                                max_matches, searched_symbol_files, types);
   }
   return 0;
 }
 
 size_t Module::FindTypesInNamespace(const SymbolContext &sc,
                                     const ConstString &type_name,
                                     const CompilerDeclContext *parent_decl_ctx,
                                     size_t max_matches, TypeList &type_list) {
   const bool append = true;
   TypeMap types_map;
   llvm::DenseSet<lldb_private::SymbolFile *> searched_symbol_files;
   size_t num_types =
-      FindTypes_Impl(sc, type_name, parent_decl_ctx, append, max_matches,
-                     searched_symbol_files, types_map);
+      FindTypes_Impl(sc, type_name.GetStringRef(), parent_decl_ctx, false,
+                     append, max_matches, searched_symbol_files, types_map);
   if (num_types > 0)
     sc.SortTypeList(types_map, type_list);
   return num_types;
 }
 
 lldb::TypeSP Module::FindFirstType(const SymbolContext &sc,
                                    const ConstString &name, bool exact_match) {
   TypeList type_list;
   llvm::DenseSet<lldb_private::SymbolFile *> searched_symbol_files;
   const size_t num_matches =
       FindTypes(sc, name, exact_match, 1, searched_symbol_files, type_list);
   if (num_matches)
     return type_list.GetTypeAtIndex(0);
   return TypeSP();
 }
 
 size_t Module::FindTypes(
     const SymbolContext &sc, const ConstString &name, bool exact_match,
     size_t max_matches,
     llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
     TypeList &types) {
+  TypeMap typesmap;
+
+  // Debug info is optimized for doing O(1) lookups on types when we know we're
+  // looking for an exact match.  But the only way for this to be possible is if
+  // we can pass this knowledge through to the SymbolFile plugin.
+  llvm::StringRef search_name = name.GetStringRef();
+  TypeClass type_class = Type::ConsumeTypeClass(search_name);
+
+  if (search_name.consume_front("::"))
+    exact_match = true;
+
+  bool success = FindTypes_Impl(sc, search_name, nullptr, exact_match, true,
+                                max_matches, searched_symbol_files, typesmap);
+
   size_t num_matches = 0;
-  const char *type_name_cstr = name.GetCString();
+  if (success) {
+    if (exact_match) {
+      // If this is something like "type lookup -- class ::Struct" it should
+      // fail.  So we need to make sure we always filter out types whose type
+      // class doesn't match.
+      typesmap.OnlyKeepTypeClass(type_class);
+    } else {
       llvm::StringRef type_scope;
       llvm::StringRef type_basename;
-  const bool append = true;
-  TypeClass type_class = eTypeClassAny;
-  TypeMap typesmap;
+      Type::GetTypeScopeAndBasename(search_name, type_scope, type_basename);
 
-  if (Type::GetTypeScopeAndBasename(type_name_cstr, type_scope, type_basename,
-                                    type_class)) {
-    // Check if "name" starts with "::" which means the qualified type starts
-    // from the root namespace and implies and exact match. The typenames we
-    // get back from clang do not start with "::" so we need to strip this off
-    // in order to get the qualified names to match
-    exact_match = type_scope.consume_front("::");
-
-    ConstString type_basename_const_str(type_basename);
-    if (FindTypes_Impl(sc, type_basename_const_str, nullptr, append,
-                       max_matches, searched_symbol_files, typesmap)) {
       typesmap.RemoveMismatchedTypes(type_scope, type_basename, type_class,
-                                     exact_match);
-      num_matches = typesmap.GetSize();
-    }
-  } else {
-    // The type is not in a namespace/class scope, just search for it by
-    // basename
-    if (type_class != eTypeClassAny && !type_basename.empty()) {
-      // The "type_name_cstr" will have been modified if we have a valid type
-      // class prefix (like "struct", "class", "union", "typedef" etc).
-      FindTypes_Impl(sc, ConstString(type_basename), nullptr, append,
-                     UINT_MAX, searched_symbol_files, typesmap);
-      typesmap.RemoveMismatchedTypes(type_scope, type_basename, type_class,
-                                     exact_match);
-      num_matches = typesmap.GetSize();
-    } else {
-      num_matches = FindTypes_Impl(sc, name, nullptr, append, UINT_MAX,
-                                   searched_symbol_files, typesmap);
-      if (exact_match) {
-        std::string name_str(name.AsCString(""));
-        typesmap.RemoveMismatchedTypes(type_scope, name_str, type_class,
-                                       exact_match);
-        num_matches = typesmap.GetSize();
-      }
+                                     false);
     }
   }
-  if (num_matches > 0)
-    sc.SortTypeList(typesmap, types);
+
+  num_matches = typesmap.GetSize();
   return num_matches;
 }
 
 SymbolVendor *Module::GetSymbolVendor(bool can_create,
                                       lldb_private::Stream *feedback_strm) {
   if (!m_did_load_symbol_vendor.load()) {
     std::lock_guard<std::recursive_mutex> guard(m_mutex);
     if (!m_did_load_symbol_vendor.load() && can_create) {
       ObjectFile *obj_file = GetObjectFile();
       if (obj_file != nullptr) {
         static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
         Timer scoped_timer(func_cat, LLVM_PRETTY_FUNCTION);
         m_symfile_ap.reset(
             SymbolVendor::FindPlugin(shared_from_this(), feedback_strm));
         m_did_load_symbol_vendor = true;
       }
     }
   }
   return m_symfile_ap.get();
 }
 

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

uint32_t FindFunctions(const lldb_private::RegularExpression &regex,
                          bool include_inlines, bool append,
                          lldb_private::SymbolContextList &sc_list) override;
 
   void GetMangledNamesForFunction(
       const std::string &scope_qualified_name,
       std::vector<lldb_private::ConstString> &mangled_names) override;
 
   uint32_t
-  FindTypes(const lldb_private::SymbolContext &sc,
-            const lldb_private::ConstString &name,
+  FindTypes(const lldb_private::SymbolContext &sc, llvm::StringRef name,
             const lldb_private::CompilerDeclContext *parent_decl_ctx,
-            bool append, uint32_t max_matches,
+            bool exact_match, 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,
                    bool append, lldb_private::TypeMap &types) override;
 
   lldb_private::TypeList *GetTypeList() override;
 

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

void SymbolFileDWARF::GetMangledNamesForFunction(
   std::set<DIERef>::iterator set_iter;
   for (set_iter = set_sp->begin(); set_iter != set_sp->end(); set_iter++) {
     DWARFDIE die = DebugInfo()->GetDIE(*set_iter);
     mangled_names.push_back(ConstString(die.GetMangledName()));
   }
 }
 
 uint32_t SymbolFileDWARF::FindTypes(
-    const SymbolContext &sc, const ConstString &name,
-    const CompilerDeclContext *parent_decl_ctx, bool append,
+    const SymbolContext &sc, llvm::StringRef name,
+    const CompilerDeclContext *parent_decl_ctx, bool exact_match, bool append,
     uint32_t max_matches,
     llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
     TypeMap &types) {
+
+  // FIXME: When exact_match is true, we should do an optimized O(1) lookup.
+  llvm::StringRef scope;
+  llvm::StringRef base;
+  bool has_namespace_separator =
+      Type::GetTypeScopeAndBasename(name, scope, base);
+  if (has_namespace_separator)
+    name = base;
+
   // If we aren't appending the results to this list, then clear the list
   if (!append)
     types.Clear();
 
   // Make sure we haven't already searched this SymbolFile before...
   if (searched_symbol_files.count(this))
     return 0;
   else
     searched_symbol_files.insert(this);
 
   DWARFDebugInfo *info = DebugInfo();
   if (info == NULL)
     return 0;
 
   Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS));
 
   if (log) {
     if (parent_decl_ctx)
       GetObjectFile()->GetModule()->LogMessage(
-          log, "SymbolFileDWARF::FindTypes (sc, name=\"%s\", parent_decl_ctx = "
-               "%p (\"%s\"), append=%u, max_matches=%u, type_list)",
-          name.GetCString(), static_cast<const void *>(parent_decl_ctx),
+          log,
+          "SymbolFileDWARF::FindTypes (sc, name=\"%s\", parent_decl_ctx = "
+          name.str().c_str(), static_cast<const void *>(parent_decl_ctx),
           parent_decl_ctx->GetName().AsCString("<NULL>"), append, max_matches);
     else
       GetObjectFile()->GetModule()->LogMessage(
-          log, "SymbolFileDWARF::FindTypes (sc, name=\"%s\", parent_decl_ctx = "
-               "NULL, append=%u, max_matches=%u, type_list)",
-          name.GetCString(), append, max_matches);
+          log,
+          "SymbolFileDWARF::FindTypes (sc, name=\"%s\", parent_decl_ctx = "
+          name.str().c_str(), append, max_matches);
   }
 
   if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
     return 0;
 
   DIEArray die_offsets;
-  m_index->GetTypes(name, die_offsets);
+  m_index->GetTypes(ConstString(name), die_offsets);
   const size_t num_die_matches = die_offsets.size();
 
   if (num_die_matches) {
     const uint32_t initial_types_size = types.GetSize();
     for (size_t i = 0; i < num_die_matches; ++i) {
       const DIERef &die_ref = die_offsets[i];
       DWARFDIE die = GetDIE(die_ref);
 
       if (die) {
         if (!DIEInDeclContext(parent_decl_ctx, die))
           continue; // The containing decl contexts don't match
 
         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());
           if (types.GetSize() >= max_matches)
             break;
         }
       } else {
-        m_index->ReportInvalidDIEOffset(die_ref.die_offset,
-                                        name.GetStringRef());
+        m_index->ReportInvalidDIEOffset(die_ref.die_offset, name);
       }
     }
     const uint32_t num_matches = types.GetSize() - initial_types_size;
     if (log && num_matches) {
       if (parent_decl_ctx) {
         GetObjectFile()->GetModule()->LogMessage(
-            log, "SymbolFileDWARF::FindTypes (sc, name=\"%s\", parent_decl_ctx "
-                 "= %p (\"%s\"), append=%u, max_matches=%u, type_list) => %u",
-            name.GetCString(), static_cast<const void *>(parent_decl_ctx),
+            log,
+            "SymbolFileDWARF::FindTypes (sc, name=\"%s\", parent_decl_ctx "
+            name.str().c_str(), static_cast<const void *>(parent_decl_ctx),
             parent_decl_ctx->GetName().AsCString("<NULL>"), append, max_matches,
             num_matches);
       } else {
         GetObjectFile()->GetModule()->LogMessage(
-            log, "SymbolFileDWARF::FindTypes (sc, name=\"%s\", parent_decl_ctx "
-                 "= NULL, append=%u, max_matches=%u, type_list) => %u",
-            name.GetCString(), append, max_matches, num_matches);
+            log,
+            "SymbolFileDWARF::FindTypes (sc, name=\"%s\", parent_decl_ctx "
+            name.str().c_str(), append, max_matches, num_matches);
       }
     }
     return num_matches;
   } else {
     UpdateExternalModuleListIfNeeded();
 
     for (const auto &pair : m_external_type_modules) {
       ModuleSP external_module_sp = pair.second;
       if (external_module_sp) {
         SymbolVendor *sym_vendor = external_module_sp->GetSymbolVendor();
         if (sym_vendor) {
-          const uint32_t num_external_matches =
-              sym_vendor->FindTypes(sc, name, parent_decl_ctx, append,
-                                    max_matches, searched_symbol_files, types);
+          const uint32_t num_external_matches = sym_vendor->FindTypes(
+              sc, name, parent_decl_ctx, exact_match, append, max_matches,
+              searched_symbol_files, types);
           if (num_external_matches)
             return num_external_matches;
         }
       }
     }
   }
 
   return 0;

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.h

public:
   FindFunctions(const lldb_private::ConstString &name,
                 const lldb_private::CompilerDeclContext *parent_decl_ctx,
                 lldb::FunctionNameType name_type_mask, bool include_inlines,
                 bool append, lldb_private::SymbolContextList &sc_list) override;
   uint32_t FindFunctions(const lldb_private::RegularExpression &regex,
                          bool include_inlines, bool append,
                          lldb_private::SymbolContextList &sc_list) override;
   uint32_t
-  FindTypes(const lldb_private::SymbolContext &sc,
-            const lldb_private::ConstString &name,
+  FindTypes(const lldb_private::SymbolContext &sc, llvm::StringRef name,
             const lldb_private::CompilerDeclContext *parent_decl_ctx,
-            bool append, uint32_t max_matches,
+            bool exact_match, bool append, uint32_t max_matches,
             llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
             lldb_private::TypeMap &types) override;
   lldb_private::CompilerDeclContext FindNamespace(
       const lldb_private::SymbolContext &sc,
       const lldb_private::ConstString &name,
       const lldb_private::CompilerDeclContext *parent_decl_ctx) override;
   size_t GetTypes(lldb_private::SymbolContextScope *sc_scope,
                   lldb::TypeClass type_mask,

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp

if (must_be_implementation == false) {
     });
 
     return type_sp;
   }
   return TypeSP();
 }
 
 uint32_t SymbolFileDWARFDebugMap::FindTypes(
-    const SymbolContext &sc, const ConstString &name,
-    const CompilerDeclContext *parent_decl_ctx, bool append,
+    const SymbolContext &sc, llvm::StringRef name,
+    const CompilerDeclContext *parent_decl_ctx, bool exact_match, bool append,
     uint32_t max_matches,
     llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
     TypeMap &types) {
   if (!append)
     types.Clear();
 
   const uint32_t initial_types_size = types.GetSize();
   SymbolFileDWARF *oso_dwarf;
 
   if (sc.comp_unit) {
     oso_dwarf = GetSymbolFile(sc);
     if (oso_dwarf)
-      return oso_dwarf->FindTypes(sc, name, parent_decl_ctx, append,
-                                  max_matches, searched_symbol_files, types);
+      return oso_dwarf->FindTypes(sc, name, parent_decl_ctx, exact_match,
+                                  append, max_matches, searched_symbol_files,
+                                  types);
   } else {
     ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool {
-      oso_dwarf->FindTypes(sc, name, parent_decl_ctx, append, max_matches,
-                           searched_symbol_files, types);
+      oso_dwarf->FindTypes(sc, name, parent_decl_ctx, exact_match, append,
+                           max_matches, searched_symbol_files, types);
       if (types.GetSize() >= max_matches)
         return true;
       else
         return false;
     });
   }
 
   return types.GetSize() - initial_types_size;

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

uint32_t FindFunctions(const ConstString &name,
                          const CompilerDeclContext *parent_decl_ctx,
                          lldb::FunctionNameType name_type_mask,
                          bool include_inlines, bool append,
                          SymbolContextList &sc_list) override;
 
   uint32_t FindFunctions(const RegularExpression &regex, bool include_inlines,
                          bool append, SymbolContextList &sc_list) override;
 
-  uint32_t FindTypes(const SymbolContext &sc, const ConstString &name,
-                     const CompilerDeclContext *parent_decl_ctx, bool append,
-                     uint32_t max_matches,
+  uint32_t FindTypes(const SymbolContext &sc, llvm::StringRef name,
+                     const CompilerDeclContext *parent_decl_ctx,
+                     bool exact_match, 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,
                    TypeMap &types) override;
 
   TypeSystem *GetTypeSystemForLanguage(lldb::LanguageType language) override;
 

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

lldb::TypeSP SymbolFileNativePDB::CreateClassStructUnion(
     PdbSymUid type_uid, llvm::StringRef name, size_t size,
     clang::TagTypeKind ttk, clang::MSInheritanceAttr::Spelling inheritance) {
 
   // Some UDT with trival ctor has zero length. Just ignore.
   if (size == 0)
     return nullptr;
 
   // Ignore unnamed-tag UDTs.
-  name = DropNameScope(name);
-  if (name.empty())
+  if (DropNameScope(name).empty())
     return nullptr;
 
   clang::DeclContext *decl_context = m_clang->GetTranslationUnitDecl();
 
   lldb::AccessType access =
       (ttk == clang::TTK_Class) ? lldb::eAccessPrivate : lldb::eAccessPublic;
 
   ClangASTMetadata metadata;

 
 uint32_t SymbolFileNativePDB::FindFunctions(const RegularExpression &regex,
                                             bool include_inlines, bool append,
                                             SymbolContextList &sc_list) {
   return 0;
 }
 
 uint32_t SymbolFileNativePDB::FindTypes(
-    const SymbolContext &sc, const ConstString &name,
-    const CompilerDeclContext *parent_decl_ctx, bool append,
+    const SymbolContext &sc, llvm::StringRef name,
+    const CompilerDeclContext *parent_decl_ctx, bool exact_match, bool append,
     uint32_t max_matches, llvm::DenseSet<SymbolFile *> &searched_symbol_files,
     TypeMap &types) {
   if (!append)
     types.Clear();
-  if (!name)
+  if (name.empty())
     return 0;
 
   searched_symbol_files.clear();
   searched_symbol_files.insert(this);
 
   // There is an assumption 'name' is not a regex
-  size_t match_count = FindTypesByName(name.GetStringRef(), max_matches, types);
+  size_t match_count = FindTypesByName(name, max_matches, types);
 
   return match_count;
 }
 
 size_t
 SymbolFileNativePDB::FindTypes(const std::vector<CompilerContext> &context,
                                bool append, TypeMap &types) {
   return 0;

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

uint32_t FindFunctions(const lldb_private::RegularExpression &regex,
                          bool include_inlines, bool append,
                          lldb_private::SymbolContextList &sc_list) override;
 
   void GetMangledNamesForFunction(
       const std::string &scope_qualified_name,
       std::vector<lldb_private::ConstString> &mangled_names) override;
 
   uint32_t
-  FindTypes(const lldb_private::SymbolContext &sc,
-            const lldb_private::ConstString &name,
+  FindTypes(const lldb_private::SymbolContext &sc, llvm::StringRef name,
             const lldb_private::CompilerDeclContext *parent_decl_ctx,
-            bool append, uint32_t max_matches,
+            bool exact_match, 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,
                    bool append, lldb_private::TypeMap &types) override;
 
   void FindTypesByRegex(const lldb_private::RegularExpression &regex,
                         uint32_t max_matches, lldb_private::TypeMap &types);
private:
 
   bool ParseCompileUnitLineTable(const lldb_private::SymbolContext &sc,
                                  uint32_t match_line);
 
   void BuildSupportFileIdToSupportFileIndexMap(
       const llvm::pdb::PDBSymbolCompiland &pdb_compiland,
       llvm::DenseMap<uint32_t, uint32_t> &index_map) const;
 
-  void FindTypesByName(const std::string &name,
+  void FindTypesByName(llvm::StringRef name,
                        const lldb_private::CompilerDeclContext *parent_decl_ctx,
                        uint32_t max_matches, lldb_private::TypeMap &types);
 
   std::string GetMangledForPDBData(const llvm::pdb::PDBSymbolData &pdb_data);
 
   lldb::VariableSP
   ParseVariableForPDBData(const lldb_private::SymbolContext &sc,
                           const llvm::pdb::PDBSymbolData &pdb_data);

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

SymbolFilePDB::FindFunctions(const lldb_private::RegularExpression &regex,
   return sc_list.GetSize() - old_size;
 }
 
 void SymbolFilePDB::GetMangledNamesForFunction(
     const std::string &scope_qualified_name,
     std::vector<lldb_private::ConstString> &mangled_names) {}
 
 uint32_t SymbolFilePDB::FindTypes(
-    const lldb_private::SymbolContext &sc,
-    const lldb_private::ConstString &name,
-    const lldb_private::CompilerDeclContext *parent_decl_ctx, bool append,
-    uint32_t max_matches,
+    const lldb_private::SymbolContext &sc, llvm::StringRef name,
+    const lldb_private::CompilerDeclContext *parent_decl_ctx, bool exact_match,
+    bool append, uint32_t max_matches,
     llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
     lldb_private::TypeMap &types) {
   if (!append)
     types.Clear();
-  if (!name)
+  if (name.empty())
     return 0;
   if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
     return 0;
 
   searched_symbol_files.clear();
   searched_symbol_files.insert(this);
 
-  std::string name_str = name.AsCString();
-
   // There is an assumption 'name' is not a regex
-  FindTypesByName(name_str, parent_decl_ctx, max_matches, types);
+  FindTypesByName(name, parent_decl_ctx, max_matches, types);
 
   return types.GetSize();
 }
 
 void SymbolFilePDB::FindTypesByRegex(
     const lldb_private::RegularExpression &regex, uint32_t max_matches,
     lldb_private::TypeMap &types) {
   // When searching by regex, we need to go out of our way to limit the search
while (auto result = results->getNext()) {
         continue;
       types.Insert(iter->second);
       ++matches;
     }
   }
 }
 
 void SymbolFilePDB::FindTypesByName(
-    const std::string &name,
+    llvm::StringRef name,
     const lldb_private::CompilerDeclContext *parent_decl_ctx,
     uint32_t max_matches, lldb_private::TypeMap &types) {
   if (!parent_decl_ctx)
     parent_decl_ctx = m_tu_decl_ctx_up.get();
   std::unique_ptr<IPDBEnumSymbols> results;
   if (name.empty())
     return;
   results = m_global_scope_up->findAllChildren(PDB_SymType::None);

lldb/source/Symbol/SymbolFile.cpp

 
 void SymbolFile::GetMangledNamesForFunction(
     const std::string &scope_qualified_name,
     std::vector<ConstString> &mangled_names) {
   return;
 }
 
 uint32_t SymbolFile::FindTypes(
-    const SymbolContext &sc, const ConstString &name,
-    const CompilerDeclContext *parent_decl_ctx, bool append,
+    const SymbolContext &sc, llvm::StringRef name,
+    const CompilerDeclContext *parent_decl_ctx, bool exact_match, bool append,
     uint32_t max_matches,
     llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
     TypeMap &types) {
   if (!append)
     types.Clear();
   return 0;
 }
 

lldb/source/Symbol/SymbolVendor.cpp

if (module_sp) {
     if (m_sym_file_ap.get())
       return m_sym_file_ap->FindFunctions(regex, include_inlines, append,
                                           sc_list);
   }
   return 0;
 }
 
 size_t SymbolVendor::FindTypes(
-    const SymbolContext &sc, const ConstString &name,
-    const CompilerDeclContext *parent_decl_ctx, bool append, size_t max_matches,
+    const SymbolContext &sc, llvm::StringRef name,
+    const CompilerDeclContext *parent_decl_ctx, bool exact_match, bool append,
+    size_t max_matches,
     llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
     TypeMap &types) {
   ModuleSP module_sp(GetModule());
   if (module_sp) {
     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
     if (m_sym_file_ap.get())
-      return m_sym_file_ap->FindTypes(sc, name, parent_decl_ctx, append,
-                                      max_matches, searched_symbol_files,
-                                      types);
+      return m_sym_file_ap->FindTypes(sc, name, parent_decl_ctx, exact_match,
+                                      append, max_matches,
+                                      searched_symbol_files, types);
   }
   if (!append)
     types.Clear();
   return 0;
 }
 
 size_t SymbolVendor::FindTypes(const std::vector<CompilerContext> &context,
                                bool append, TypeMap &types) {

lldb/source/Symbol/Type.cpp

if (a_uid > b_uid)
     return 1;
   return 0;
 }
 
 ConstString Type::GetQualifiedName() {
   return GetForwardCompilerType().GetConstTypeName();
 }
 
-bool Type::GetTypeScopeAndBasename(const llvm::StringRef& name,
+TypeClass Type::ConsumeTypeClass(llvm::StringRef &name) {
+  if (name.consume_front("struct "))
+    return eTypeClassStruct;
+  else if (name.consume_front("class "))
+    return eTypeClassClass;
+  else if (name.consume_front("union "))
+    return eTypeClassUnion;
+  else if (name.consume_front("enum "))
+    return eTypeClassEnumeration;
+  else if (name.consume_front("typedef "))
+    return eTypeClassTypedef;
+  return eTypeClassAny;
+}
+
+bool Type::GetTypeScopeAndBasename(const llvm::StringRef &name,
                                    llvm::StringRef &scope,
-                                   llvm::StringRef &basename,
-                                   TypeClass &type_class) {
-  type_class = eTypeClassAny;
-
+                                   llvm::StringRef &basename) {
   if (name.empty())
     return false;
 
   basename = name;
-  if (basename.consume_front("struct "))
-    type_class = eTypeClassStruct;
-  else if (basename.consume_front("class "))
-    type_class = eTypeClassClass;
-  else if (basename.consume_front("union "))
-    type_class = eTypeClassUnion;
-  else if (basename.consume_front("enum "))
-    type_class = eTypeClassEnumeration;
-  else if (basename.consume_front("typedef "))
-    type_class = eTypeClassTypedef;
-
   size_t namespace_separator = basename.find("::");
   if (namespace_separator == llvm::StringRef::npos)
     return false;
 
   size_t template_begin = basename.find('<');
   while (namespace_separator != llvm::StringRef::npos) {
     if (template_begin != llvm::StringRef::npos &&
         namespace_separator > template_begin) {

lldb/source/Symbol/TypeList.cpp

for (iterator pos = m_types.begin(), end = m_types.end(); pos != end; ++pos) {
     pos->get()->Dump(s, show_context);
   }
 }
 
 void TypeList::RemoveMismatchedTypes(const char *qualified_typename,
                                      bool exact_match) {
   llvm::StringRef type_scope;
   llvm::StringRef type_basename;
-  TypeClass type_class = eTypeClassAny;
+  llvm::StringRef name(qualified_typename);
+  TypeClass type_class = Type::ConsumeTypeClass(name);
   if (!Type::GetTypeScopeAndBasename(qualified_typename, type_scope,
-                                     type_basename, type_class)) {
+                                     type_basename)) {
     type_basename = qualified_typename;
     type_scope = "";
   }
   return RemoveMismatchedTypes(type_scope, type_basename, type_class,
                                exact_match);
 }
 
 void TypeList::RemoveMismatchedTypes(const std::string &type_scope,
for (pos = m_types.begin(); pos != end; ++pos) {
     if (type_class != eTypeClassAny) {
       match_type_class = the_type->GetForwardCompilerType().GetTypeClass();
       if ((match_type_class & type_class) == 0)
         continue;
     }
 
     ConstString match_type_name_const_str(the_type->GetQualifiedName());
     if (match_type_name_const_str) {
-      const char *match_type_name = match_type_name_const_str.GetCString();
+      llvm::StringRef match_type_name =
+          match_type_name_const_str.GetStringRef();
       llvm::StringRef match_type_scope;
       llvm::StringRef match_type_basename;
       if (Type::GetTypeScopeAndBasename(match_type_name, match_type_scope,
-                                        match_type_basename,
-                                        match_type_class)) {
+                                        match_type_basename)) {
         if (match_type_basename == type_basename) {
           const size_t type_scope_size = type_scope.size();
           const size_t match_type_scope_size = match_type_scope.size();
           if (exact_match || (type_scope_size == match_type_scope_size)) {
             keep_match = match_type_scope == type_scope;
           } else {
             if (match_type_scope_size > type_scope_size) {
               const size_t type_scope_pos = match_type_scope.rfind(type_scope);

lldb/source/Symbol/TypeMap.cpp

 void TypeMap::Dump(Stream *s, bool show_context) {
   for (iterator pos = m_types.begin(), end = m_types.end(); pos != end; ++pos) {
     pos->second->Dump(s, show_context);
   }
 }
 
 void TypeMap::RemoveMismatchedTypes(const char *qualified_typename,
                                     bool exact_match) {
+  llvm::StringRef name(qualified_typename);
   llvm::StringRef type_scope;
   llvm::StringRef type_basename;
-  TypeClass type_class = eTypeClassAny;
+  TypeClass type_class = Type::ConsumeTypeClass(name);
   if (!Type::GetTypeScopeAndBasename(qualified_typename, type_scope,
-                                     type_basename, type_class)) {
+                                     type_basename)) {
     type_basename = qualified_typename;
     type_scope = "";
   }
   return RemoveMismatchedTypes(type_scope, type_basename, type_class,
                                exact_match);
 }
 
+void TypeMap::OnlyKeepTypeClass(lldb::TypeClass type_class) {
+  if (type_class == eTypeClassAny)
+    return;
+
+  collection matching_types;
+
+  iterator pos, end = m_types.end();
+
+  for (const auto &t : m_types) {
+    TypeClass tc = t.second->GetForwardCompilerType().GetTypeClass();
+    if (tc & type_class)
+      matching_types.insert(t);
+  }
+  m_types.swap(matching_types);
+}
+
 void TypeMap::RemoveMismatchedTypes(const std::string &type_scope,
                                     const std::string &type_basename,
                                     TypeClass type_class, bool exact_match) {
   // Our "collection" type currently is a std::map which doesn't have any good
   // way to iterate and remove items from the map so we currently just make a
   // new list and add all of the matching types to it, and then swap it into
   // m_types at the end
   collection matching_types;
for (pos = m_types.begin(); pos != end; ++pos) {
     }
 
     ConstString match_type_name_const_str(the_type->GetQualifiedName());
     if (match_type_name_const_str) {
       const char *match_type_name = match_type_name_const_str.GetCString();
       llvm::StringRef match_type_scope;
       llvm::StringRef match_type_basename;
       if (Type::GetTypeScopeAndBasename(match_type_name, match_type_scope,
-                                        match_type_basename,
-                                        match_type_class)) {
+                                        match_type_basename)) {
         if (match_type_basename == type_basename) {
           const size_t type_scope_size = type_scope.size();
           const size_t match_type_scope_size = match_type_scope.size();
           if (exact_match || (type_scope_size == match_type_scope_size)) {
             keep_match = match_type_scope == type_scope;
           } else {
             if (match_type_scope_size > type_scope_size) {
               const size_t type_scope_pos = match_type_scope.rfind(type_scope);

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

Error opts::symbols::findTypes(lldb_private::Module &Module) {
   if (!ContextOr)
     return ContextOr.takeError();
   CompilerDeclContext *ContextPtr =
       ContextOr->IsValid() ? &*ContextOr : nullptr;
 
   SymbolContext SC;
   DenseSet<SymbolFile *> SearchedFiles;
   TypeMap Map;
-  Vendor.FindTypes(SC, ConstString(Name), ContextPtr, true, UINT32_MAX,
-                   SearchedFiles, Map);
+  Vendor.FindTypes(SC, Name, ContextPtr, false, true, UINT32_MAX, SearchedFiles,
+                   Map);
 
   outs() << formatv("Found {0} types:\n", Map.GetSize());
   StreamString Stream;
   Map.Dump(&Stream, false);
   outs() << Stream.GetData() << "\n";
   return Error::success();
 }
 

lldb/unittests/Symbol/TestType.cpp

 using namespace lldb_private;
 
 namespace {
 void TestGetTypeScopeAndBasenameHelper(const char *full_type,
                                        bool expected_is_scoped,
                                        const char *expected_scope,
                                        const char *expected_name) {
   llvm::StringRef scope, name;
-  lldb::TypeClass type_class;
-  bool is_scoped =
-      Type::GetTypeScopeAndBasename(full_type, scope, name, type_class);
+  bool is_scoped = Type::GetTypeScopeAndBasename(full_type, scope, name);
   EXPECT_EQ(is_scoped, expected_is_scoped);
   if (expected_is_scoped) {
     EXPECT_EQ(scope, expected_scope);
     EXPECT_EQ(name, expected_name);
   }
 }
 }