Add option eTypeOptionHideEmptyAggregates.

[sivachandra]

Summary

For certain data structures, when the synthetic child provider returns
zero children, a summary like "Empty instance of <typename>" could be
more appropriate than something like "size=0 {}". This new option helps
hide the trailing "{}".

This is also exposed with a -h option for the command "type summary add".

[sivachandra]

I will add tests if the general direction of this change is OK.

[granata.enrico]

The change itself seems fine, just a couple minor things:

• I have some ideas on what should happen if synthetic children fail to produce values for whatever reason. This change itself does not conflict with any of that, though, so it's good to go
• Is there going to be a flag to "type summary add" for setting your new flag, or is this only meant for internal formatters?
• How do you plan to test it?
• If anything, maybe replace Print with Expand, to get ShouldExpandEmptyAggregates(). We are indeed printing the aggregate, just not "expanding" it

[sivachandra]

On Thu, Jul 23, 2015 at 2:17 PM, Enrico Granata <[e-mail]> wrote:

• Is there going to be a flag to "type summary add" for setting your new flag, or is this only meant for internal formatters?

I have only envisioned using such an option in scripts. If you feel it would be relevant/complete to expose it in the "type summary flags", I will do it as a follow up unless you want me to do it with this change itself.

• How do you plan to test it?

I am testing my change locally by having a type summary script along with a synthetic children provider script which returns 0 children. I will add the same as a test for this patch.

• If anything, maybe replace Print with Expand, to get ShouldExpandEmptyAggregates(). We are indeed printing the aggregate, just not "expanding" it

Will do it.

[granata.enrico]

In D11473#211047, @sivachandra wrote:

On Thu, Jul 23, 2015 at 2:17 PM, Enrico Granata <[e-mail]> wrote:

• Is there going to be a flag to "type summary add" for setting your new flag, or is this only meant for internal formatters?

I have only envisioned using such an option in scripts. If you feel it would be relevant/complete to expose it in the "type summary flags", I will do it as a follow up unless you want me to do it with this change itself.

It seems like a generally useful option to have, since we're adding this ability to the summary, to set it at the command line for a formatter you are creating yourself

• How do you plan to test it?

I am testing my change locally by having a type summary script along with a synthetic children provider script which returns 0 children. I will add the same as a test for this patch.

Of course this mode would work just as well for a type which just happens to have zero children "organically", as in:

struct S {};
S myS;

I don't think there should be anything specific to synthetic children here, even though I see why that's mostly useful there
My general theory would be for synthetic children to be able to fail-safe themselves, as in, recognize that some of their preconditions are not met (imagine an std::list<T> with a NULL base pointer), and then fall back to displaying the actual child values. The issue you run into is that the summary is independent of the synthetic children, so you risk getting a mismatch between what the summary says and the content you see.
For instance, a list might store its count inline, but then have a bogus first-node pointer, so you would get, say, "size =5" and then incorrect children.
I have yet to figure out a sustainable strategy for that, but that's way beyond the scope of this change.

• If anything, maybe replace Print with Expand, to get ShouldExpandEmptyAggregates(). We are indeed printing the aggregate, just not "expanding" it

Will do it.

[clayborg]

I am OK if Enrico is ok with this.

[sivachandra]

Expose the new option in the "type summary add" command via a -h option.

[sivachandra]

Ping. How does this look now?

[granata.enrico]

If the test suite passes, go ahead and commit

include/lldb/DataFormatters/TypeSummary.h

public:
             SetDontShowChildren (bool value = true)
             {
                 if (value)
                     m_flags |= lldb::eTypeOptionHideChildren;
                 else
                     m_flags &= ~lldb::eTypeOptionHideChildren;
                 return *this;
             }
-            
             bool
+            GetHideEmptyAggregates () const
+            {
+                return (m_flags & lldb::eTypeOptionHideEmptyAggregates) == lldb::eTypeOptionHideEmptyAggregates;
+            }
+
+            Flags&
+            SetHideEmptyAggregates (bool value = true)
+            {
+                if (value)
+                    m_flags |= lldb::eTypeOptionHideEmptyAggregates;
+                else
+                    m_flags &= ~lldb::eTypeOptionHideEmptyAggregates;
+                return *this;
+            }
+            
+            bool
             GetDontShowValue () const
             {
                 return (m_flags & lldb::eTypeOptionHideValue) == lldb::eTypeOptionHideValue;
             }
             
             Flags&
             SetDontShowValue (bool value = true)
             {
public:
             return m_flags.GetNonCacheable();
         }
         
         virtual bool
         DoesPrintChildren (ValueObject* valobj) const
         {
             return !m_flags.GetDontShowChildren();
         }
-        
         virtual bool
+        DoesPrintEmptyAggregates () const
+        {
+            return !m_flags.GetHideEmptyAggregates();
+        }
+        
+        virtual bool
         DoesPrintValue (ValueObject* valobj) const
         {
             return !m_flags.GetDontShowValue();
         }
         
         bool
         IsOneLiner () const
         {

include/lldb/DataFormatters/ValueObjectPrinter.h

protected:
     
     bool
     PrintObjectDescriptionIfNeeded (bool value_printed,
                                     bool summary_printed);
     
     bool
     ShouldPrintChildren (bool is_failed_description,
                          uint32_t& curr_ptr_depth);
-    
+    bool
+    ShouldExpandEmptyAggregates ();
+    
     ValueObject*
     GetValueObjectForChildrenGeneration ();
     
     void
     PrintChildrenPreamble ();
     
     void
     PrintChildrenPostamble (bool print_dotdotdot);

include/lldb/lldb-enumerations.h

enum CommandArgumentType
     };
 
     //----------------------------------------------------------------------
     // Options that can be set for a formatter to alter its behavior
     // Not all of these are applicable to all formatter types
     //----------------------------------------------------------------------
     FLAGS_ENUM(TypeOptions)
     {
-        eTypeOptionNone            = (0u),
-        eTypeOptionCascade         = (1u << 0),
-        eTypeOptionSkipPointers    = (1u << 1),
-        eTypeOptionSkipReferences  = (1u << 2),
-        eTypeOptionHideChildren    = (1u << 3),
-        eTypeOptionHideValue       = (1u << 4),
-        eTypeOptionShowOneLiner    = (1u << 5),
-        eTypeOptionHideNames       = (1u << 6),
-        eTypeOptionNonCacheable    = (1u << 7)
+        eTypeOptionNone                = (0u),
+        eTypeOptionCascade             = (1u << 0),
+        eTypeOptionSkipPointers        = (1u << 1),
+        eTypeOptionSkipReferences      = (1u << 2),
+        eTypeOptionHideChildren        = (1u << 3),
+        eTypeOptionHideValue           = (1u << 4),
+        eTypeOptionShowOneLiner        = (1u << 5),
+        eTypeOptionHideNames           = (1u << 6),
+        eTypeOptionNonCacheable        = (1u << 7),
+        eTypeOptionHideEmptyAggregates = (1u << 8)
     };
 
    //----------------------------------------------------------------------
    // This is the return value for frame comparisons.  If you are comparing frame A to frame B
    // the following cases arise:
    // 1) When frame A pushes frame B (or a frame that ends up pushing B) A is Older than B.
    // 2) When frame A pushed frame B (or if frame A is on the stack but B is not) A is Younger than B
    // 3) When frame A and frame B have the same StackID, they are Equal.

source/Commands/CommandObjectType.cpp

switch (short_option)
         case 'C':
             m_flags.SetCascades(Args::StringToBoolean(option_arg, true, &success));
             if (!success)
                 error.SetErrorStringWithFormat("invalid value for cascade: %s", option_arg);
             break;
         case 'e':
             m_flags.SetDontShowChildren(false);
             break;
+        case 'h':
+            m_flags.SetHideEmptyAggregates(true);
+            break;
         case 'v':
             m_flags.SetDontShowValue(true);
             break;
         case 'c':
             m_flags.SetShowMembersOneLiner(true);
             break;
         case 's':
             m_format_string = std::string(option_arg);
CommandObjectTypeSummaryAdd::CommandOptions::g_option_table[] =
     { LLDB_OPT_SET_ALL, false,  "regex", 'x', OptionParser::eNoArgument, NULL, NULL, 0, eArgTypeNone,    "Type names are actually regular expressions."},
     { LLDB_OPT_SET_1  , true, "inline-children", 'c', OptionParser::eNoArgument, NULL, NULL, 0, eArgTypeNone,    "If true, inline all child values into summary string."},
     { LLDB_OPT_SET_1  , false, "omit-names", 'O', OptionParser::eNoArgument, NULL, NULL, 0, eArgTypeNone,    "If true, omit value names in the summary display."},
     { LLDB_OPT_SET_2  , true, "summary-string", 's', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeSummaryString,    "Summary string used to display text and object contents."},
     { LLDB_OPT_SET_3, false, "python-script", 'o', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypePythonScript, "Give a one-liner Python script as part of the command."},
     { LLDB_OPT_SET_3, false, "python-function", 'F', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypePythonFunction, "Give the name of a Python function to use for this type."},
     { LLDB_OPT_SET_3, false, "input-python", 'P', OptionParser::eNoArgument, NULL, NULL, 0, eArgTypeNone, "Input Python code to use for this type manually."},
     { LLDB_OPT_SET_2 | LLDB_OPT_SET_3,   false, "expand", 'e', OptionParser::eNoArgument, NULL, NULL, 0, eArgTypeNone,    "Expand aggregate data types to show children on separate lines."},
+    { LLDB_OPT_SET_2 | LLDB_OPT_SET_3,   false, "hide-empty", 'h', OptionParser::eNoArgument, NULL, NULL, 0, eArgTypeNone,    "Do not expand aggregate data types with no children."},
     { LLDB_OPT_SET_2 | LLDB_OPT_SET_3,   false, "name", 'n', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeName,    "A name for this summary string."},
     { 0, false, NULL, 0, 0, NULL, NULL, 0, eArgTypeNone, NULL }
 };
 
 
 //-------------------------------------------------------------------------
 // CommandObjectTypeSummaryDelete
 //-------------------------------------------------------------------------

source/DataFormatters/ValueObjectPrinter.cpp

if (is_failed_description || m_curr_depth < options.m_max_depth)
         
         TypeSummaryImpl* entry = GetSummaryFormatter();
 
         return (!entry || entry->DoesPrintChildren(m_valobj) || m_summary.empty());
     }
     return false;
 }
 
+bool
+ValueObjectPrinter::ShouldExpandEmptyAggregates ()
+{
+    TypeSummaryImpl* entry = GetSummaryFormatter();
+
+    if (!entry)
+        return true;
+
+    return entry->DoesPrintEmptyAggregates();
+}
+
 ValueObject*
 ValueObjectPrinter::GetValueObjectForChildrenGeneration ()
 {
     return m_valobj;
 }
 
 void
 ValueObjectPrinter::PrintChildrenPreamble ()
if (num_children)
         PrintChildrenPostamble (print_dotdotdot);
     }
     else if (IsAggregate())
     {
         // Aggregate, no children...
         if (ShouldPrintValueObject())
         {
             // if it has a synthetic value, then don't print {}, the synthetic children are probably only being used to vend a value
-            if (m_valobj->DoesProvideSyntheticValue())
+            if (m_valobj->DoesProvideSyntheticValue() || !ShouldExpandEmptyAggregates())
                 m_stream->PutCString( "\n");
             else
                 m_stream->PutCString(" {}\n");
         }
     }
     else
     {
         if (ShouldPrintValueObject())

test/functionalities/data-formatter/data-formatter-synth/TestDataFormatterSynth.py

def data_formatter_commands(self):
         self.runCmd("type filter add BagOfBags --child x.z")
         self.expect('frame variable bag_bag',
             substrs = ['x.z = 71'])
 
         self.runCmd("n")
         self.expect('frame variable bag_bag',
                     substrs = ['x.z = 12'])
 
+        self.runCmd('type summary add -e -s "I am always empty but have" EmptyStruct')
+        self.expect('frame variable es', substrs = ["I am always empty but have {}"])
+        self.runCmd('type summary add -e -h -s "I am really empty" EmptyStruct')
+        self.expect('frame variable es', substrs = ["I am really empty"])
+        self.expect('frame variable es', substrs = ["I am really empty {}"], matching=False)
+
 
 if __name__ == '__main__':
     import atexit
     lldb.SBDebugger.Initialize()
     atexit.register(lambda: lldb.SBDebugger.Terminate())
     unittest2.main()

test/functionalities/data-formatter/data-formatter-synth/main.cpp

struct BagOfBags
     BagOfFloats q;
     BagOfBags() : 
     x('E'),
     y('B'),
     z(1.1),
     q(20.11) {}
 };
 
+struct EmptyStruct {};
+
 struct Plenty
 {
     BagOfInts *some_values;
     int* array;
     int array_size;
     int bitfield;
     
     Plenty(int N, bool flagA, bool flagB) :
     some_values(new BagOfInts(N)),
     array(new int[N]),
     array_size(N),
     bitfield( (flagA ? 0x01 : 0x00) | (flagB ? 0x10 : 0x00) )
     {
         for (int j = 0; j < N; j++)
             array[j] = N-j;
     }
 };
 
 int main (int argc, const char * argv[])
 {
     BagOfInts int_bag(6);
     BagOfFloats float_bag(2.71);
     
     BagOfBags bag_bag;
+    EmptyStruct es;
     
     Plenty plenty_of_stuff(5,true,false);
     
     plenty_of_stuff.bitfield = 0x11; // Set break point at this line.
     
     bag_bag.x.z = 12;
     
     return 0;
     
 }
 

test/python_api/formatters/TestFormattersSBAPI.py

def formatters(self):
              lldb.SBTypeSummary.CreateWithSummaryString("hello static world",
              lldb.eTypeOptionNone))
 
         summary = foo_ptr.GetTypeSummary()
 
         self.assertTrue(summary.IsValid(), "no summary found for foo* when one was in place")
         self.assertTrue(summary.GetData() == "hello static world", "wrong summary found for foo*")
 
+        self.expect("frame variable e1", substrs=["I am an empty Empty1 {}"])
+        self.expect("frame variable e2", substrs=["I am an empty Empty2"])
+        self.expect("frame variable e2", substrs=["I am an empty Empty2 {}"], matching=False)
+
     def force_synth_off(self):
         """Test that one can have the public API return non-synthetic SBValues if desired"""
         self.runCmd("file no_synth", CURRENT_EXECUTABLE_SET)
 
         lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
 
         self.runCmd("run", RUN_SUCCEEDED)
 

test/python_api/formatters/main.cpp

struct FooType
   short F;
 };
 
 struct CCC
 {
   int a, b, c;
 };
 
+struct Empty1 { void *data; };
+struct Empty2 { void *data; };
+
 
 int main(int argc, char const *argv[]) {
   JustAStruct foo;
   foo.A = 1;
   foo.B = 3.14;
   foo.C = 'e';
   foo.D = 6.28;
   foo.E = 3100419850;
   foo.F = 0;
 
   FooType bar;
   bar.A = 1;
   bar.B = 3.14;
   bar.C = 'e';
   bar.D = 6.28;
   bar.E = 3100419850;
   bar.F = 0;
   JustAStruct* foo_ptr = &foo;
 
   std::vector<int> int_vector;
 
   CCC ccc = {111, 222, 333};
 
+        Empty1 e1;
+        Empty2 e2;
+
   return 0; // Set break point at this line.
 }

test/python_api/formatters/synth.py

def get_child_at_index(self, index):
         if index == 0:
             return self._sbvalue.GetChildMemberWithName("a")
         if index == 1:
             return self._sbvalue.GetChildMemberWithName("b")
         if index == 2:
             return self._sbvalue.GetChildMemberWithName("c")
 
 
+def empty1_summary(sbvalue, internal_dict):
+    return "I am an empty Empty1"
+
+
+class Empty1SynthProvider(object):
+    def __init__(self, sbvalue, internal_dict):
+        self._sbvalue = sbvalue
+
+    def num_children(self):
+        return 0
+
+    def get_child_at_index(self, index):
+        return None
+
+
+def empty2_summary(sbvalue, internal_dict):
+    return "I am an empty Empty2"
+
+
+class Empty2SynthProvider(object):
+    def __init__(self, sbvalue, internal_dict):
+        self._sbvalue = sbvalue
+
+    def num_children(self):
+        return 0
+
+    def get_child_at_index(self, index):
+        return None
+
+
 def __lldb_init_module(debugger,dict):
      debugger.CreateCategory("JASSynth").AddTypeSynthetic(lldb.SBTypeNameSpecifier("JustAStruct"),
         lldb.SBTypeSynthetic.CreateWithClassName("synth.jasSynthProvider"))
      cat = lldb.debugger.CreateCategory("CCCSynth")
      cat.AddTypeSynthetic(
          lldb.SBTypeNameSpecifier("CCC"),
          lldb.SBTypeSynthetic.CreateWithClassName("synth.CCCSynthProvider",
                                                   lldb.eTypeOptionCascade))
      cat.AddTypeSummary(
          lldb.SBTypeNameSpecifier("CCC"),
          lldb.SBTypeSummary.CreateWithFunctionName("synth.ccc_summary",
                                                    lldb.eTypeOptionCascade))
-
-
+     cat.AddTypeSynthetic(
+         lldb.SBTypeNameSpecifier("Empty1"),
+         lldb.SBTypeSynthetic.CreateWithClassName("synth.Empty1SynthProvider"))
+     cat.AddTypeSummary(
+         lldb.SBTypeNameSpecifier("Empty1"),
+         lldb.SBTypeSummary.CreateWithFunctionName("synth.empty1_summary"))
+     cat.AddTypeSynthetic(
+         lldb.SBTypeNameSpecifier("Empty2"),
+         lldb.SBTypeSynthetic.CreateWithClassName("synth.Empty2SynthProvider"))
+     cat.AddTypeSummary(
+         lldb.SBTypeNameSpecifier("Empty2"),
+         lldb.SBTypeSummary.CreateWithFunctionName("synth.empty2_summary",
+                                                   lldb.eTypeOptionHideEmptyAggregates))