Introduce the concept of a type that is meaningless without dynamic resolution, which are essentially placeholder types meant to appease a language's type system but do not offer any actual information to the debugger, unless further resolved

This is currently meant for data formatters to know to ignore such types in caching and lookup

llvm-svn: 250767

lldb/include/lldb/Symbol/CompilerType.h

@@ -462,6 +462,9 @@ public:
     LazyBool
     ShouldPrintAsOneLiner () const;
     
+    bool
+    IsMeaninglessWithoutDynamicResolution () const;
+    
     //------------------------------------------------------------------
     // Pointers & References
     //------------------------------------------------------------------

lldb/include/lldb/Symbol/TypeSystem.h

@@ -528,6 +528,18 @@ public:
     virtual LazyBool
     ShouldPrintAsOneLiner (void* type);
     
+    // Type systems can have types that are placeholder types, which are meant to indicate
+    // the presence of a type, but offer no actual information about said types, and leave
+    // the burden of actually figuring type information out to dynamic type resolution. For instance
+    // a language with a generics system, can use placeholder types to indicate "type argument goes here",
+    // without promising uniqueness of the placeholder, nor attaching any actually idenfiable information
+    // to said placeholder. This API allows type systems to tell LLDB when such a type has been encountered
+    // In response, the debugger can react by not using this type as a cache entry in any type-specific way
+    // For instance, LLDB will currently not cache any formatters that are discovered on such a type as
+    // attributable to the meaningless type itself, instead preferring to use the dynamic type
+    virtual bool
+    IsMeaninglessWithoutDynamicResolution (void* type);
+    
 protected:
     const LLVMCastKind m_kind; // Support for llvm casting
     SymbolFile *m_sym_file;

lldb/source/DataFormatters/FormatManager.cpp

@@ -210,11 +210,15 @@ FormatManager::GetPossibleMatches (ValueObject& valobj,
         entries.push_back({bitfieldname,0,did_strip_ptr,did_strip_ref,did_strip_typedef});
         reason |= lldb_private::eFormatterChoiceCriterionStrippedBitField;
     }
+
+    if (!compiler_type.IsMeaninglessWithoutDynamicResolution())
+    {
         entries.push_back({type_name,reason,did_strip_ptr,did_strip_ref,did_strip_typedef});
 
         ConstString display_type_name(compiler_type.GetDisplayTypeName());
         if (display_type_name != type_name)
             entries.push_back({display_type_name,reason,did_strip_ptr,did_strip_ref,did_strip_typedef});
+    }
 
     for (bool is_rvalue_ref = true, j = true; j && compiler_type.IsReferenceType(nullptr, &is_rvalue_ref); j = false)
     {
@@ -641,22 +645,12 @@ ConstString
 FormatManager::GetTypeForCache (ValueObject& valobj,
                                 lldb::DynamicValueType use_dynamic)
 {
-    if (use_dynamic == lldb::eNoDynamicValues)
+    ValueObjectSP valobj_sp = valobj.GetQualifiedRepresentationIfAvailable(use_dynamic, valobj.IsSynthetic());
+    if (valobj_sp && valobj_sp->GetCompilerType().IsValid())
     {
-        if (valobj.IsDynamic())
-        {
-            if (valobj.GetStaticValue())
-                return valobj.GetStaticValue()->GetQualifiedTypeName();
-            else
-                return ConstString();
+        if (!valobj_sp->GetCompilerType().IsMeaninglessWithoutDynamicResolution())
+            return valobj_sp->GetQualifiedTypeName();
     }
-        else
-            return valobj.GetQualifiedTypeName();
-    }
-    if (valobj.IsDynamic())
-        return valobj.GetQualifiedTypeName();
-    if (valobj.GetDynamicValue(use_dynamic))
-        return valobj.GetDynamicValue(use_dynamic)->GetQualifiedTypeName();
     return ConstString();
 }
 

lldb/source/Symbol/CompilerType.cpp

@@ -867,6 +867,14 @@ CompilerType::ShouldPrintAsOneLiner () const
     return eLazyBoolCalculate;
 }
 
+bool
+CompilerType::IsMeaninglessWithoutDynamicResolution () const
+{
+    if (IsValid())
+        return m_type_system->IsMeaninglessWithoutDynamicResolution(m_type);
+    return false;
+}
+
 // Get the index of the child of "clang_type" whose name matches. This function
 // doesn't descend into the children, but only looks one level deep and name
 // matches can include base class names.

lldb/source/Symbol/TypeSystem.cpp

@@ -109,6 +109,12 @@ TypeSystem::ShouldPrintAsOneLiner (void* type)
     return eLazyBoolCalculate;
 }
 
+bool
+TypeSystem::IsMeaninglessWithoutDynamicResolution (void* type)
+{
+    return false;
+}
+
 #pragma mark TypeSystemMap
 
 TypeSystemMap::TypeSystemMap() :