Add test for SBValue.GetNonSyntheticValue in presence of synth provider.

[granata.enrico]

Looks good. Thanks.

test/python_api/formatters/TestFormattersSBAPI.py

def formatters(self):
              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 ./jas_synth.py")
+        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.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)

test/python_api/formatters/jas_synth.py

-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 __lldb_init_module(debugger,dict):
-     debugger.CreateCategory("JASSynth").AddTypeSynthetic(lldb.SBTypeNameSpecifier("JustAStruct"),
-        lldb.SBTypeSynthetic.CreateWithClassName("jas_synth.jasSynthProvider"))
-

test/python_api/formatters/main.cpp

struct FooType
   int A;
   float B;
   char C;
   double D;
   long E;
   short F;
 };
 
+struct CCC
+{
+  int a, b, c;
+};
+
+
 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};
+
   return 0; // Set break point at this line.
 }

test/python_api/formatters/synth.py

+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 __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))
+
+