Vendor import of lldb trunk r256945:

https://llvm.org/svn/llvm-project/lldb/trunk@256945

4 files changed, 518 insertions, 0 deletions

diff --git a/packages/Python/lldbsuite/test/python_api/formatters/Makefile b/packages/Python/lldbsuite/test/python_api/formatters/Makefile
new file mode 100644
index 0000000..ddffdcf
--- /dev/null
+++ b/packages/Python/lldbsuite/test/python_api/formatters/Makefile
@@ -0,0 +1,8 @@
+LEVEL = ../../make
+
+CXX_SOURCES := main.cpp
+
+# Clean renamed executable on 'make clean'
+clean: OBJECTS+=no_synth
+
+include $(LEVEL)/Makefile.rules
diff --git a/packages/Python/lldbsuite/test/python_api/formatters/TestFormattersSBAPI.py b/packages/Python/lldbsuite/test/python_api/formatters/TestFormattersSBAPI.py
new file mode 100644
index 0000000..de7f15f
--- /dev/null
+++ b/packages/Python/lldbsuite/test/python_api/formatters/TestFormattersSBAPI.py
@@ -0,0 +1,346 @@
+"""Test Python APIs for working with formatters"""
+
+from __future__ import print_function
+
+
+
+import os, sys, time
+import lldb
+from lldbsuite.test.lldbtest import *
+import lldbsuite.test.lldbutil as lldbutil
+
+class SBFormattersAPITestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    def setUp(self):
+        # Call super's setUp().
+        TestBase.setUp(self)
+        self.line = line_number('main.cpp', '// Set break point at this line.')
+
+    @add_test_categories(['pyapi'])
+    def test_formatters_api(self):
+        """Test Python APIs for working with formatters"""
+        self.build()
+        self.setTearDownCleanup()
+        
+        """Test Python APIs for working with formatters"""
+        self.runCmd("file a.out", 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)
+
+        # The stop reason of the thread should be breakpoint.
+        self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
+            substrs = ['stopped',
+                       'stop reason = breakpoint'])
+        
+        # This is the function to remove the custom formats in order to have a
+        # clean slate for the next test case.
+        def cleanup():
+            self.runCmd('type format clear', check=False)
+            self.runCmd('type summary clear', check=False)
+            self.runCmd('type filter clear', check=False)
+            self.runCmd('type synthetic clear', check=False)
+            self.runCmd('type category delete foobar', check=False)
+            self.runCmd('type category delete JASSynth', check=False)
+            self.runCmd('type category delete newbar', check=False)
+
+        # Execute the cleanup function during test case tear down.
+        self.addTearDownHook(cleanup)
+
+
+        format = lldb.SBTypeFormat(lldb.eFormatHex)
+        category = self.dbg.GetDefaultCategory()
+        category.AddTypeFormat(lldb.SBTypeNameSpecifier("int"),format)
+
+        self.expect("frame variable foo.A",
+             substrs = ['0x00000001'])
+        self.expect("frame variable foo.E", matching=False,
+             substrs = ['b8cca70a'])
+
+        category.AddTypeFormat(lldb.SBTypeNameSpecifier("long"),format)
+        self.expect("frame variable foo.A",
+             substrs = ['0x00000001'])
+        self.expect("frame variable foo.E",
+             substrs = ['b8cca70a'])
+        
+        format.format = lldb.eFormatOctal
+        category.AddTypeFormat(lldb.SBTypeNameSpecifier("int"),format)
+        self.expect("frame variable foo.A",
+             substrs = ['01'])
+        self.expect("frame variable foo.E",
+             substrs = ['b8cca70a'])
+        
+        category.DeleteTypeFormat(lldb.SBTypeNameSpecifier("int"))
+        category.DeleteTypeFormat(lldb.SBTypeNameSpecifier("long"))
+        self.expect("frame variable foo.A", matching=False,
+             substrs = ['01'])
+        self.expect("frame variable foo.E", matching=False,
+             substrs = ['b8cca70a'])
+
+        summary = lldb.SBTypeSummary.CreateWithSummaryString("the hello world you'll never see")
+        summary.SetSummaryString('hello world')
+        new_category = self.dbg.GetCategory("foobar")
+        self.assertFalse(new_category.IsValid(), "getting a non-existing category worked")
+        new_category = self.dbg.CreateCategory("foobar")
+        new_category.enabled = True
+        new_category.AddTypeSummary(lldb.SBTypeNameSpecifier("^.*t$",True),summary)
+        self.expect("frame variable foo.A",
+             substrs = ['hello world'])
+        self.expect("frame variable foo.E", matching=False,
+             substrs = ['hello world'])
+        self.expect("frame variable foo.B",
+             substrs = ['hello world'])
+        self.expect("frame variable foo.F",
+             substrs = ['hello world'])
+        new_category.enabled = False
+        self.expect("frame variable foo.A", matching=False,
+             substrs = ['hello world'])
+        self.expect("frame variable foo.E", matching=False,
+             substrs = ['hello world'])
+        self.expect("frame variable foo.B", matching=False,
+             substrs = ['hello world'])
+        self.expect("frame variable foo.F", matching=False,
+             substrs = ['hello world'])
+        self.dbg.DeleteCategory(new_category.GetName())
+        self.expect("frame variable foo.A", matching=False,
+             substrs = ['hello world'])
+        self.expect("frame variable foo.E", matching=False,
+             substrs = ['hello world'])
+        self.expect("frame variable foo.B", matching=False,
+             substrs = ['hello world'])
+        self.expect("frame variable foo.F", matching=False,
+             substrs = ['hello world'])
+
+        filter = lldb.SBTypeFilter(0)
+        filter.AppendExpressionPath("A")
+        filter.AppendExpressionPath("D")
+        self.assertTrue(filter.GetNumberOfExpressionPaths() == 2, "filter with two items does not have two items")
+
+        category.AddTypeFilter(lldb.SBTypeNameSpecifier("JustAStruct"),filter)
+        self.expect("frame variable foo",
+             substrs = ['A = 1', 'D = 6.28'])
+        self.expect("frame variable foo", matching=False,
+             substrs = ['B = ', 'C = ', 'E = ', 'F = '])
+
+        category.DeleteTypeFilter(lldb.SBTypeNameSpecifier("JustAStruct",True))
+        self.expect("frame variable foo",
+             substrs = ['A = 1', 'D = 6.28'])
+        self.expect("frame variable foo", matching=False,
+             substrs = ['B = ', 'C = ', 'E = ', 'F = '])
+
+        category.DeleteTypeFilter(lldb.SBTypeNameSpecifier("JustAStruct",False))
+        self.expect("frame variable foo",
+             substrs = ['A = 1', 'D = 6.28'])
+        self.expect("frame variable foo", matching=True,
+             substrs = ['B = ', 'C = ', 'E = ', 'F = '])
+
+        self.runCmd("command script import --allow-reload ./synth.py")
+
+        self.expect("frame variable foo", matching=False,
+             substrs = ['X = 1'])
+
+        self.dbg.GetCategory("JASSynth").SetEnabled(True)
+        self.expect("frame variable foo", matching=True,
+             substrs = ['X = 1'])
+
+        self.dbg.GetCategory("CCCSynth").SetEnabled(True)
+        self.expect("frame variable ccc", matching=True,
+             substrs = ['CCC object with leading value (int) a = 111', 'a = 111', 'b = 222', 'c = 333'])
+
+        foo_var = self.dbg.GetSelectedTarget().GetProcess().GetSelectedThread().GetSelectedFrame().FindVariable('foo')
+        self.assertTrue(foo_var.IsValid(), 'could not find foo')
+        self.assertTrue(foo_var.GetDeclaration().IsValid(), 'foo declaration is invalid')
+
+        self.assertTrue(foo_var.GetNumChildren() == 2, 'synthetic value has wrong number of child items (synth)')
+        self.assertTrue(foo_var.GetChildMemberWithName('X').GetValueAsUnsigned() == 1, 'foo_synth.X has wrong value (synth)')
+        self.assertFalse(foo_var.GetChildMemberWithName('B').IsValid(), 'foo_synth.B is valid but should not (synth)')
+
+        self.dbg.GetCategory("JASSynth").SetEnabled(False)
+        foo_var = self.dbg.GetSelectedTarget().GetProcess().GetSelectedThread().GetSelectedFrame().FindVariable('foo')
+        self.assertTrue(foo_var.IsValid(), 'could not find foo')
+
+        self.assertFalse(foo_var.GetNumChildren() == 2, 'still seeing synthetic value')
+
+        filter = lldb.SBTypeFilter(0)
+        filter.AppendExpressionPath("A")
+        filter.AppendExpressionPath("D")
+        category.AddTypeFilter(lldb.SBTypeNameSpecifier("JustAStruct"),filter)
+        self.expect("frame variable foo",
+             substrs = ['A = 1', 'D = 6.28'])
+
+        foo_var = self.dbg.GetSelectedTarget().GetProcess().GetSelectedThread().GetSelectedFrame().FindVariable('foo')
+        self.assertTrue(foo_var.IsValid(), 'could not find foo')
+
+        self.assertTrue(foo_var.GetNumChildren() == 2, 'synthetic value has wrong number of child items (filter)')
+        self.assertTrue(foo_var.GetChildMemberWithName('X').GetValueAsUnsigned() == 0, 'foo_synth.X has wrong value (filter)')
+        self.assertTrue(foo_var.GetChildMemberWithName('A').GetValueAsUnsigned() == 1, 'foo_synth.A has wrong value (filter)')
+
+        self.assertTrue(filter.ReplaceExpressionPathAtIndex(0,"C"), "failed to replace an expression path in filter")
+        self.expect("frame variable foo",
+             substrs = ['A = 1', 'D = 6.28'])
+        category.AddTypeFilter(lldb.SBTypeNameSpecifier("JustAStruct"),filter)
+        self.expect("frame variable foo",
+             substrs = ["C = 'e'", 'D = 6.28'])
+        category.AddTypeFilter(lldb.SBTypeNameSpecifier("FooType"),filter)
+        filter.ReplaceExpressionPathAtIndex(1,"F")
+        self.expect("frame variable foo",
+             substrs = ["C = 'e'", 'D = 6.28'])
+        category.AddTypeFilter(lldb.SBTypeNameSpecifier("JustAStruct"),filter)
+        self.expect("frame variable foo",
+             substrs = ["C = 'e'", 'F = 0'])
+        self.expect("frame variable bar",
+             substrs = ["C = 'e'", 'D = 6.28'])
+
+        foo_var = self.dbg.GetSelectedTarget().GetProcess().GetSelectedThread().GetSelectedFrame().FindVariable('foo')
+        self.assertTrue(foo_var.IsValid(), 'could not find foo')
+        self.assertTrue(foo_var.GetChildMemberWithName('C').GetValueAsUnsigned() == ord('e'), 'foo_synth.C has wrong value (filter)')
+
+        chosen = self.dbg.GetFilterForType(lldb.SBTypeNameSpecifier("JustAStruct"))
+        self.assertTrue(chosen.count == 2, "wrong filter found for JustAStruct")
+        self.assertTrue(chosen.GetExpressionPathAtIndex(0) == 'C', "wrong item at index 0 for JustAStruct")
+        self.assertTrue(chosen.GetExpressionPathAtIndex(1) == 'F', "wrong item at index 1 for JustAStruct")
+
+        self.assertFalse(category.DeleteTypeFilter(lldb.SBTypeNameSpecifier("NoSuchType")),"deleting a non-existing filter worked")
+        self.assertFalse(category.DeleteTypeSummary(lldb.SBTypeNameSpecifier("NoSuchType")),"deleting a non-existing summary worked")
+        self.assertFalse(category.DeleteTypeFormat(lldb.SBTypeNameSpecifier("NoSuchType")),"deleting a non-existing format worked")
+        self.assertFalse(category.DeleteTypeSynthetic(lldb.SBTypeNameSpecifier("NoSuchType")),"deleting a non-existing synthetic worked")
+
+        self.assertFalse(category.DeleteTypeFilter(lldb.SBTypeNameSpecifier("")),"deleting a filter for '' worked")
+        self.assertFalse(category.DeleteTypeSummary(lldb.SBTypeNameSpecifier("")),"deleting a summary for '' worked")
+        self.assertFalse(category.DeleteTypeFormat(lldb.SBTypeNameSpecifier("")),"deleting a format for '' worked")
+        self.assertFalse(category.DeleteTypeSynthetic(lldb.SBTypeNameSpecifier("")),"deleting a synthetic for '' worked")
+
+        try:
+             self.assertFalse(category.AddTypeSummary(lldb.SBTypeNameSpecifier("NoneSuchType"), None), "adding a summary valued None worked")
+        except:
+             pass
+        else:
+             self.assertFalse(True, "adding a summary valued None worked")
+
+        try:
+             self.assertFalse(category.AddTypeFilter(lldb.SBTypeNameSpecifier("NoneSuchType"), None), "adding a filter valued None worked")
+        except:
+             pass
+        else:
+             self.assertFalse(True, "adding a filter valued None worked")
+
+        try:
+             self.assertFalse(category.AddTypeSynthetic(lldb.SBTypeNameSpecifier("NoneSuchType"), None), "adding a synthetic valued None worked")
+        except:
+             pass
+        else:
+             self.assertFalse(True, "adding a synthetic valued None worked")
+
+        try:
+             self.assertFalse(category.AddTypeFormat(lldb.SBTypeNameSpecifier("NoneSuchType"), None), "adding a format valued None worked")
+        except:
+             pass
+        else:
+             self.assertFalse(True, "adding a format valued None worked")
+
+
+        self.assertFalse(category.AddTypeSummary(lldb.SBTypeNameSpecifier("EmptySuchType"), lldb.SBTypeSummary()), "adding a summary without value worked")
+        self.assertFalse(category.AddTypeFilter(lldb.SBTypeNameSpecifier("EmptySuchType"), lldb.SBTypeFilter()), "adding a filter without value worked")
+        self.assertFalse(category.AddTypeSynthetic(lldb.SBTypeNameSpecifier("EmptySuchType"), lldb.SBTypeSynthetic()), "adding a synthetic without value worked")
+        self.assertFalse(category.AddTypeFormat(lldb.SBTypeNameSpecifier("EmptySuchType"), lldb.SBTypeFormat()), "adding a format without value worked")
+
+        self.assertFalse(category.AddTypeSummary(lldb.SBTypeNameSpecifier(""), lldb.SBTypeSummary.CreateWithSummaryString("")), "adding a summary for an invalid type worked")
+        self.assertFalse(category.AddTypeFilter(lldb.SBTypeNameSpecifier(""), lldb.SBTypeFilter(0)), "adding a filter for an invalid type worked")
+        self.assertFalse(category.AddTypeSynthetic(lldb.SBTypeNameSpecifier(""), lldb.SBTypeSynthetic.CreateWithClassName("")), "adding a synthetic for an invalid type worked")
+        self.assertFalse(category.AddTypeFormat(lldb.SBTypeNameSpecifier(""), lldb.SBTypeFormat(lldb.eFormatHex)), "adding a format for an invalid type worked")
+
+        new_category = self.dbg.CreateCategory("newbar")
+        new_category.AddTypeSummary(lldb.SBTypeNameSpecifier("JustAStruct"),
+             lldb.SBTypeSummary.CreateWithScriptCode("return 'hello scripted world';"))
+        self.expect("frame variable foo", matching=False,
+             substrs = ['hello scripted world'])
+        new_category.enabled = True
+        self.expect("frame variable foo", matching=True,
+             substrs = ['hello scripted world'])
+
+        self.expect("frame variable foo_ptr", matching=True,
+             substrs = ['hello scripted world'])
+        new_category.AddTypeSummary(lldb.SBTypeNameSpecifier("JustAStruct"),
+             lldb.SBTypeSummary.CreateWithScriptCode("return 'hello scripted world';",
+             lldb.eTypeOptionSkipPointers))
+        self.expect("frame variable foo", matching=True,
+             substrs = ['hello scripted world'])
+
+        frame = self.dbg.GetSelectedTarget().GetProcess().GetSelectedThread().GetSelectedFrame()
+        foo_ptr = frame.FindVariable("foo_ptr")
+        summary = foo_ptr.GetTypeSummary()
+
+        self.assertFalse(summary.IsValid(), "summary found for foo* when none was planned")
+
+        self.expect("frame variable foo_ptr", matching=False,
+             substrs = ['hello scripted world'])
+
+        new_category.AddTypeSummary(lldb.SBTypeNameSpecifier("JustAStruct"),
+             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)
+        
+        self.assertTrue(self.dbg.GetCategory(lldb.eLanguageTypeObjC) is not None, "ObjC category is None")
+
+    @add_test_categories(['pyapi'])
+    def test_force_synth_off(self):
+        """Test that one can have the public API return non-synthetic SBValues if desired"""
+        self.build(dictionary={'EXE':'no_synth'})
+        self.setTearDownCleanup()
+
+        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)
+
+        # The stop reason of the thread should be breakpoint.
+        self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
+            substrs = ['stopped',
+                       'stop reason = breakpoint'])
+
+        # This is the function to remove the custom formats in order to have a
+        # clean slate for the next test case.
+        def cleanup():
+            self.runCmd('type format clear', check=False)
+            self.runCmd('type summary clear', check=False)
+            self.runCmd('type filter clear', check=False)
+            self.runCmd('type synthetic clear', check=False)
+            self.runCmd('type category delete foobar', check=False)
+            self.runCmd('type category delete JASSynth', check=False)
+            self.runCmd('type category delete newbar', check=False)
+            self.runCmd('settings set target.enable-synthetic-value true')
+
+        # Execute the cleanup function during test case tear down.
+        self.addTearDownHook(cleanup)
+
+        frame = self.dbg.GetSelectedTarget().GetProcess().GetSelectedThread().GetSelectedFrame()
+        int_vector = frame.FindVariable("int_vector")
+        if self.TraceOn():
+             print(int_vector)
+        self.assertTrue(int_vector.GetNumChildren() == 0, 'synthetic vector is empty')
+
+        self.runCmd('settings set target.enable-synthetic-value false')
+        frame = self.dbg.GetSelectedTarget().GetProcess().GetSelectedThread().GetSelectedFrame()
+        int_vector = frame.FindVariable("int_vector")
+        if self.TraceOn():
+             print(int_vector)
+        self.assertFalse(int_vector.GetNumChildren() == 0, '"physical" vector is not empty')
+
+        self.runCmd('settings set target.enable-synthetic-value true')
+        frame = self.dbg.GetSelectedTarget().GetProcess().GetSelectedThread().GetSelectedFrame()
+        int_vector = frame.FindVariable("int_vector")
+        if self.TraceOn():
+             print(int_vector)
+        self.assertTrue(int_vector.GetNumChildren() == 0, 'synthetic vector is still empty')
diff --git a/packages/Python/lldbsuite/test/python_api/formatters/main.cpp b/packages/Python/lldbsuite/test/python_api/formatters/main.cpp
new file mode 100644
index 0000000..f21c956
--- /dev/null
+++ b/packages/Python/lldbsuite/test/python_api/formatters/main.cpp
@@ -0,0 +1,59 @@
+#include <stdio.h>
+#include <vector>
+
+struct JustAStruct
+{
+	int A;
+	float B;
+	char C;
+	double D;
+	long E;
+	short F;
+};
+
+struct FooType
+{
+	int A;
+	float B;
+	char C;
+	double D;
+	long E;
+	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.
+}
diff --git a/packages/Python/lldbsuite/test/python_api/formatters/synth.py b/packages/Python/lldbsuite/test/python_api/formatters/synth.py
new file mode 100644
index 0000000..5a30c9a
--- /dev/null
+++ b/packages/Python/lldbsuite/test/python_api/formatters/synth.py
@@ -0,0 +1,105 @@
+import lldb
+
+class jasSynthProvider:
+     def __init__(self, valobj, dict):
+         self.valobj = valobj;
+     def num_children(self):
+         return 2;
+     def get_child_at_index(self, index):
+         child = None
+         if index == 0:
+             child = self.valobj.GetChildMemberWithName('A');
+         if index == 1:
+             child = self.valobj.CreateValueFromExpression('X', '(int)1')
+         return child;
+     def get_child_index(self, name):
+         if name == 'A':
+             return 0;
+         if name == 'X':
+             return 1;
+         return None;
+
+
+def ccc_summary(sbvalue, internal_dict):
+    sbvalue = sbvalue.GetNonSyntheticValue()
+    # This tests that the SBValue.GetNonSyntheticValue() actually returns a
+    # non-synthetic value. If it does not, then sbvalue.GetChildMemberWithName("a")
+    # in the following statement will call the 'get_child_index' method of the
+    # synthetic child provider CCCSynthProvider below (which raises an exception).
+    return "CCC object with leading value " + str(sbvalue.GetChildMemberWithName("a"))
+
+
+class CCCSynthProvider(object):
+    def __init__(self, sbvalue, internal_dict):
+        self._sbvalue = sbvalue
+
+    def num_children(self):
+        return 3
+
+    def get_child_index(self, name):
+        raise RuntimeError("I don't want to be called!")
+
+    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))