Really test type lookup in TestCppTypeLookup.py

[friss]

Summary

... and fix one bug found this way. Currently, the test works not because
types are looked up correctly, but because by injecting local variables
we also materialize the types for Clang. If we disable the local variable
injection, then one check fails.

The reason of the failure is that FindTypes is run with max_matches==1
and this value is passed down to the symbol lookup functions. When the
search is performed only on the basename (like it's the case for an
entity defined in the root namespace), then the search will stop after
having found one match on the basename. But that match might be in a
namespace, we were really just looking up the basename in the accelerator
tables.

The solution is to not pass max_matches down, but to search without a
limit and let RemoveMismatchedTypes do its job afterwards. Note the
patch includes 2 hunks with the same change, but only the latter is
tested. I couldn't find a way to create a testcase for the other
branch of the if ('image lookup -t' allows me to get there, but it
only ever returns one type anyway).

[clayborg]

main problem with this approach is if the client tries to lookup "reference_type" as an example... It will end up pulling in and completing every STL type and returning the typedef only for us to weed this out.

Nothing we can do about this at the moment unless we make our SymbolFile::FindType() take some extra parameters where we can specify a decl content in an abstract way (like "at the tranlsation unit level, find me 'reference_unit', or "in class A and in class B find 'reference_type'". For now we could try to specify a parent_decl_context that is the translation unit, but we would need to fix the lookup code to fill in the correct translation unit for each module.

So for now, this works and is our best solution, but there are many problems with out type lookup that do need to be fixed, but those will need to happen later.

packages/Python/lldbsuite/test/lang/cpp/type_lookup/TestCppTypeLookup.py

def test_namespace_only(self):
         self.build()
         self.main_source_file = lldb.SBFileSpec("main.cpp")
         (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(
             self, "Set a breakpoint here", self.main_source_file)
 
         # Get frame for current thread
         frame = thread.GetSelectedFrame()
 
+        # We are testing LLDB's type lookup machinery, but if we inject local
+        # variables, the types for those will be found because they have been
+        # imported through the variable, not because the type lookup worked.
+        self.runCmd("settings set target.experimental.inject-local-vars false")
+
         # Make sure we don't accidentally accept structures that exist only
         # in namespaces when evaluating expressions with top level types.
         # Prior to the revision that added this test, we would accidentally
         # accept types from namespaces, so this will ensure we don't regress
         # to that behavior again
         expr_result = frame.EvaluateExpression("*((namespace_only *)&i)")
         self.assertTrue(expr_result.GetError().Fail(),
                         "'namespace_only' exists in namespace only")

source/Core/Module.cpp

size_t Module::FindTypes(
     TypeList &types) {
   size_t num_matches = 0;
   const char *type_name_cstr = name.GetCString();
   llvm::StringRef type_scope;
   llvm::StringRef type_basename;
   const bool append = true;
   TypeClass type_class = eTypeClassAny;
   TypeMap typesmap;
+
   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,
-                     max_matches, searched_symbol_files, typesmap);
+                     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, max_matches,
+      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);
       }
     }
   }