Revert "[lldb] Add Pythonic API to SBStructuredData extension (#155061)" (#156728)

Reverts #155061 (and #156721) which caused Crashlog shell tests to break.

Author: kastiglione

lldb/bindings/interface/SBStructuredDataExtensions.i

@@ -3,121 +3,16 @@ STRING_EXTENSION_OUTSIDE(SBStructuredData)
 %extend lldb::SBStructuredData {
 #ifdef SWIGPYTHON
     %pythoncode%{
+    def __int__(self):
+      return self.GetSignedInteger()
+
     def __len__(self):
       '''Return the number of element in a lldb.SBStructuredData object.'''
       return self.GetSize()
 
     def __iter__(self):
         '''Iterate over all the elements in a lldb.SBStructuredData object.'''
-        data_type = self.GetType()
-        if data_type == eStructuredDataTypeArray:
-            for i in range(self.GetSize()):
-                yield self.GetItemAtIndex(i).dynamic
-            return
-        elif data_type == eStructuredDataTypeDictionary:
-            keys = SBStringList()
-            self.GetKeys(keys)
-            return iter(keys)
-        else:
-            raise TypeError(f"cannot iterate {self.type_name(data_type)} type")
-
-    def __getitem__(self, key):
-        data_type = self.GetType()
-        if data_type == eStructuredDataTypeArray:
-            if not isinstance(key, int):
-                raise TypeError("subscript index must be an integer")
-            count = len(self)
-            if -count <= key < count:
-                key %= count
-                return self.GetItemAtIndex(key).dynamic
-            raise IndexError("index out of range")
-        elif data_type == eStructuredDataTypeDictionary:
-            if not isinstance(key, str):
-                raise TypeError("subscript key must be a string")
-            return self.GetValueForKey(key).dynamic
-        else:
-            raise TypeError(f"cannot subscript {self.type_name(data_type)} type")
-
-    def __bool__(self):
-        data_type = self.GetType()
-        if data_type == eStructuredDataTypeInvalid:
-            return False
-        elif data_type in (
-            eStructuredDataTypeArray,
-            eStructuredDataTypeDictionary,
-        ):
-            return self.GetSize() != 0
-        elif data_type != eStructuredDataTypeGeneric:
-            return bool(self.dynamic)
-        else:
-            raise TypeError("cannot convert generic to bool")
-
-    def __int__(self):
-        data_type = self.GetType()
-        if data_type in (
-            eStructuredDataTypeInteger,
-            eStructuredDataTypeSignedInteger,
-        ):
-            return int(self.dynamic)
-        else:
-            raise TypeError(f"cannot convert {self.type_name(data_type)} to int")
-
-    def __float__(self):
-        data_type = self.GetType()
-        if data_type in (
-            eStructuredDataTypeFloat,
-            eStructuredDataTypeInteger,
-            eStructuredDataTypeSignedInteger,
-        ):
-            return float(self.dynamic)
-        else:
-            raise TypeError(f"cannot convert {self.type_name(data_type)} to float")
-
-    @property
-    def dynamic(self):
-        data_type = self.GetType()
-        if data_type == eStructuredDataTypeNull:
-            return None
-        elif data_type == eStructuredDataTypeBoolean:
-            return self.GetBooleanValue()
-        elif data_type == eStructuredDataTypeInteger:
-            return self.GetUnsignedIntegerValue()
-        elif data_type == eStructuredDataTypeSignedInteger:
-            return self.GetSignedIntegerValue()
-        elif data_type == eStructuredDataTypeFloat:
-            return self.GetFloatValue()
-        elif data_type == eStructuredDataTypeString:
-            size = len(self) or 1023
-            return self.GetStringValue(size + 1)
-        elif data_type == eStructuredDataTypeGeneric:
-            return self.GetGenericValue()
-        else:
-            return self
-
-    @staticmethod
-    def type_name(t):
-        if t == eStructuredDataTypeNull:
-            return "null"
-        elif t == eStructuredDataTypeBoolean:
-            return "boolean"
-        elif t == eStructuredDataTypeInteger:
-            return "integer"
-        elif t == eStructuredDataTypeSignedInteger:
-            return "integer"
-        elif t == eStructuredDataTypeFloat:
-            return "float"
-        elif t == eStructuredDataTypeString:
-            return "string"
-        elif t == eStructuredDataTypeArray:
-            return "array"
-        elif t == eStructuredDataTypeDictionary:
-            return "dictionary"
-        elif t == eStructuredDataTypeGeneric:
-            return "generic"
-        elif t == eStructuredDataTypeInvalid:
-            return "invalid"
-        else:
-            raise TypeError(f"unknown structured data type: {t}")
+        return lldb_iter(self, 'GetSize', 'GetItemAtIndex')
     %}
 #endif
 }

lldb/test/API/python_api/sbstructureddata/TestStructuredDataAPI.py

@@ -48,11 +48,10 @@ def structured_data_api_test(self):
         s.Clear()
         error = example.GetDescription(s)
         self.assertSuccess(error, "GetDescription works")
-        # Ensure str() doesn't raise an exception.
-        self.assertTrue(str(example))
         if not "key_float" in s.GetData():
             self.fail("FAILED: could not find key_float in description output")
 
+        dict_struct = lldb.SBStructuredData()
         dict_struct = example.GetValueForKey("key_dict")
 
         # Tests for dictionary data type
@@ -114,26 +113,21 @@ class MyRandomClass:
         self.assertSuccess(example.SetFromJSON("1"))
         self.assertEqual(example.GetType(), lldb.eStructuredDataTypeInteger)
         self.assertEqual(example.GetIntegerValue(), 1)
-        self.assertEqual(int(example), 1)
 
         self.assertSuccess(example.SetFromJSON("4.19"))
         self.assertEqual(example.GetType(), lldb.eStructuredDataTypeFloat)
         self.assertEqual(example.GetFloatValue(), 4.19)
-        self.assertEqual(float(example), 4.19)
 
         self.assertSuccess(example.SetFromJSON('"Bonjour, 123!"'))
         self.assertEqual(example.GetType(), lldb.eStructuredDataTypeString)
         self.assertEqual(example.GetStringValue(42), "Bonjour, 123!")
-        self.assertEqual(str(example), "Bonjour, 123!")
 
         self.assertSuccess(example.SetFromJSON("true"))
         self.assertEqual(example.GetType(), lldb.eStructuredDataTypeBoolean)
         self.assertTrue(example.GetBooleanValue())
-        self.assertTrue(example)
 
         self.assertSuccess(example.SetFromJSON("null"))
         self.assertEqual(example.GetType(), lldb.eStructuredDataTypeNull)
-        self.assertFalse(example)
 
         example = lldb.SBStructuredData()
         example.SetUnsignedIntegerValue(1)
@@ -193,35 +187,38 @@ class MyRandomClass:
         self.assertEqual(sb_data, example_arr)
 
     def invalid_struct_test(self, example):
+        invalid_struct = lldb.SBStructuredData()
         invalid_struct = example.GetValueForKey("invalid_key")
         if invalid_struct.IsValid():
             self.fail("An invalid object should have been returned")
 
         # Check Type API
-        if invalid_struct.GetType() != lldb.eStructuredDataTypeInvalid:
+        if not invalid_struct.GetType() == lldb.eStructuredDataTypeInvalid:
             self.fail("Wrong type returned: " + str(invalid_struct.GetType()))
 
     def dictionary_struct_test(self, example):
         # Check API returning a valid SBStructuredData of 'dictionary' type
+        dict_struct = lldb.SBStructuredData()
         dict_struct = example.GetValueForKey("key_dict")
         if not dict_struct.IsValid():
             self.fail("A valid object should have been returned")
 
         # Check Type API
-        if dict_struct.GetType() != lldb.eStructuredDataTypeDictionary:
+        if not dict_struct.GetType() == lldb.eStructuredDataTypeDictionary:
             self.fail("Wrong type returned: " + str(dict_struct.GetType()))
 
         # Check Size API for 'dictionary' type
-        if dict_struct.GetSize() != 6:
+        if not dict_struct.GetSize() == 6:
             self.fail("Wrong no of elements returned: " + str(dict_struct.GetSize()))
 
     def string_struct_test(self, dict_struct):
+        string_struct = lldb.SBStructuredData()
         string_struct = dict_struct.GetValueForKey("key_string")
         if not string_struct.IsValid():
             self.fail("A valid object should have been returned")
 
         # Check Type API
-        if string_struct.GetType() != lldb.eStructuredDataTypeString:
+        if not string_struct.GetType() == lldb.eStructuredDataTypeString:
             self.fail("Wrong type returned: " + str(string_struct.GetType()))
 
         # Check API returning 'string' value
@@ -241,17 +238,18 @@ def uint_struct_test(self, dict_struct):
         # Check a valid SBStructuredData containing an unsigned integer.
         # We intentionally make this larger than what an int64_t can hold but
         # still small enough to fit a uint64_t
+        uint_struct = lldb.SBStructuredData()
         uint_struct = dict_struct.GetValueForKey("key_uint")
         if not uint_struct.IsValid():
             self.fail("A valid object should have been returned")
 
         # Check Type API
-        if uint_struct.GetType() != lldb.eStructuredDataTypeInteger:
+        if not uint_struct.GetType() == lldb.eStructuredDataTypeInteger:
             self.fail("Wrong type returned: " + str(uint_struct.GetType()))
 
         # Check API returning unsigned integer value
         output = uint_struct.GetUnsignedIntegerValue()
-        if output != 0xFFFFFFFF00000000:
+        if not output == 0xFFFFFFFF00000000:
             self.fail("wrong output: " + str(output))
 
         # Calling wrong API on a SBStructuredData
@@ -264,17 +262,18 @@ def sint_struct_test(self, dict_struct):
         # Check a valid SBStructuredData containing an signed integer.
         # We intentionally make this smaller than what an uint64_t can hold but
         # still small enough to fit a int64_t
+        sint_struct = lldb.SBStructuredData()
         sint_struct = dict_struct.GetValueForKey("key_sint")
         if not sint_struct.IsValid():
             self.fail("A valid object should have been returned")
 
         # Check Type API
-        if sint_struct.GetType() != lldb.eStructuredDataTypeSignedInteger:
+        if not sint_struct.GetType() == lldb.eStructuredDataTypeSignedInteger:
             self.fail("Wrong type returned: " + str(sint_struct.GetType()))
 
         # Check API returning signed integer value
         output = sint_struct.GetSignedIntegerValue()
-        if output != -42:
+        if not output == -42:
             self.fail("wrong output: " + str(output))
 
         # Calling wrong API on a SBStructuredData
@@ -284,26 +283,28 @@ def sint_struct_test(self, dict_struct):
             self.fail("Valid string " + output + " returned for an integer object")
 
     def double_struct_test(self, dict_struct):
+        floating_point_struct = lldb.SBStructuredData()
         floating_point_struct = dict_struct.GetValueForKey("key_float")
         if not floating_point_struct.IsValid():
             self.fail("A valid object should have been returned")
 
         # Check Type API
-        if floating_point_struct.GetType() != lldb.eStructuredDataTypeFloat:
+        if not floating_point_struct.GetType() == lldb.eStructuredDataTypeFloat:
             self.fail("Wrong type returned: " + str(floating_point_struct.GetType()))
 
         # Check API returning 'double' value
         output = floating_point_struct.GetFloatValue()
-        if output != 2.99:
+        if not output == 2.99:
             self.fail("wrong output: " + str(output))
 
     def bool_struct_test(self, dict_struct):
+        bool_struct = lldb.SBStructuredData()
         bool_struct = dict_struct.GetValueForKey("key_bool")
         if not bool_struct.IsValid():
             self.fail("A valid object should have been returned")
 
         # Check Type API
-        if bool_struct.GetType() != lldb.eStructuredDataTypeBoolean:
+        if not bool_struct.GetType() == lldb.eStructuredDataTypeBoolean:
             self.fail("Wrong type returned: " + str(bool_struct.GetType()))
 
         # Check API returning 'bool' value
@@ -313,108 +314,35 @@ def bool_struct_test(self, dict_struct):
 
     def array_struct_test(self, dict_struct):
         # Check API returning a valid SBStructuredData of 'array' type
+        array_struct = lldb.SBStructuredData()
         array_struct = dict_struct.GetValueForKey("key_array")
         if not array_struct.IsValid():
             self.fail("A valid object should have been returned")
 
         # Check Type API
-        if array_struct.GetType() != lldb.eStructuredDataTypeArray:
+        if not array_struct.GetType() == lldb.eStructuredDataTypeArray:
             self.fail("Wrong type returned: " + str(array_struct.GetType()))
 
         # Check Size API for 'array' type
-        if array_struct.GetSize() != 2:
+        if not array_struct.GetSize() == 2:
             self.fail("Wrong no of elements returned: " + str(array_struct.GetSize()))
 
         # Check API returning a valid SBStructuredData for different 'array'
         # indices
         string_struct = array_struct.GetItemAtIndex(0)
         if not string_struct.IsValid():
             self.fail("A valid object should have been returned")
-        if string_struct.GetType() != lldb.eStructuredDataTypeString:
+        if not string_struct.GetType() == lldb.eStructuredDataTypeString:
             self.fail("Wrong type returned: " + str(string_struct.GetType()))
         output = string_struct.GetStringValue(5)
-        if output != "23":
+        if not output == "23":
             self.fail("wrong output: " + str(output))
 
         string_struct = array_struct.GetItemAtIndex(1)
         if not string_struct.IsValid():
             self.fail("A valid object should have been returned")
-        if string_struct.GetType() != lldb.eStructuredDataTypeString:
+        if not string_struct.GetType() == lldb.eStructuredDataTypeString:
             self.fail("Wrong type returned: " + str(string_struct.GetType()))
         output = string_struct.GetStringValue(5)
-        if output != "arr":
+        if not output == "arr":
             self.fail("wrong output: " + str(output))
-
-    def test_round_trip_scalars(self):
-        for original in (0, 11, -1, 0.0, 4.5, -0.25, True, False):
-            constructor = type(original)
-            data = lldb.SBStructuredData()
-            data.SetFromJSON(json.dumps(original))
-            round_tripped = constructor(data)
-            self.assertEqual(round_tripped, original)
-
-    def test_dynamic(self):
-        for original in (0, 11, -1, 0.0, 4.5, -0.25, "", "dirk", True, False):
-            data = lldb.SBStructuredData()
-            data.SetFromJSON(json.dumps(original))
-            self.assertEqual(data.dynamic, original)
-
-    def test_round_trip_int(self):
-        for original in (0, 11, -1):
-            data = lldb.SBStructuredData()
-            data.SetFromJSON(json.dumps(original))
-            self.assertEqual(int(data), int(original))
-
-    def test_round_trip_float(self):
-        for original in (0, 11, -1, 0.0, 4.5, -0.25):
-            data = lldb.SBStructuredData()
-            data.SetFromJSON(json.dumps(original))
-            self.assertEqual(float(data), float(original))
-
-    def test_round_trip_bool(self):
-        for original in (0, 11, -1, 0.0, 4.5, -0.25, "0.0", "4.5", "-0.25"):
-            data = lldb.SBStructuredData()
-            data.SetFromJSON(json.dumps(original))
-            self.assertEqual(bool(data), bool(original))
-
-        for original in ([], {}, [1], {1: 1}):
-            data = lldb.SBStructuredData()
-            data.SetFromJSON(json.dumps(original))
-            self.assertEqual(bool(data), bool(original))
-
-    def test_assert_false(self):
-        self.assertFalse(lldb.SBStructuredData())
-        for original in ("0", "0.0", '""', "[]", "{}"):
-            data = lldb.SBStructuredData()
-            data.SetFromJSON(original)
-            self.assertFalse(data)
-
-    def test_iterate_array(self):
-        array = [0, 1, 2]
-        data = lldb.SBStructuredData()
-        data.SetFromJSON(json.dumps(array))
-        for value in data:
-            self.assertEqual(value, array.pop(0))
-
-    def test_iterate_dictionary(self):
-        dictionary = {"0": 0, "1": 1, "2": 2}
-        keys = set(dictionary.keys())
-        data = lldb.SBStructuredData()
-        data.SetFromJSON(json.dumps(dictionary))
-        for key in data:
-            self.assertIn(key, keys)
-            keys.remove(key)
-
-    def test_getitem_array(self):
-        array = [1, 2, 3]
-        data = lldb.SBStructuredData()
-        data.SetFromJSON(json.dumps(array))
-        for i in range(len(array)):
-            self.assertEqual(data[i], array[i])
-
-    def test_getitem_dictionary(self):
-        dictionary = {"one": 1, "two": 2, "three": 3}
-        data = lldb.SBStructuredData()
-        data.SetFromJSON(json.dumps(dictionary))
-        for key in dictionary:
-            self.assertEqual(data[key], dictionary[key])