[lldb] StructuredData should not truncate uint64_t values

[bulbazord]

Summary

In json::Value, getAsInteger returns an optional<int64_t> and getAsNumber
returns an optional<double>. If a value is larger than what an int64_t
can hold but smaller than what a uint64_t can hold, the getAsInteger
function will fail but the getAsNumber will succeed. However, the value
shouldn't be interpreted as a double.

rdar://105556974

[mib]

Should we also add a negative integer to the dictionary to make sure this didn't cause a regression ?

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

23–31

Ditto (hex)

136

nit: I think the hex representation would be cleaner.

[bulbazord]

In D144238#4133940, @mib wrote:

Should we also add a negative integer to the dictionary to make sure this didn't cause a regression ?

Negative integers are not correctly handled currently. I plan on fixing that in a follow-up. See:

(lldb) script
Python Interactive Interpreter. To exit, type 'quit()', 'exit()' or Ctrl-D.
>>> foo = lldb.SBStructuredData()
>>> foo.SetFromJSON('{"foo": -5}')
error: <NULL>
>>> foo.GetValueForKey('foo').GetIntegerValue()
18446744073709551611

[mib]

LGTM then (with nits ;p)

[bulbazord]

Address comments

lldb/source/Utility/StructuredData.cpp

if (json::Array *A = value.getAsArray())
     return ParseJSONArray(A);
 
   if (auto s = value.getAsString())
     return std::make_shared<StructuredData::String>(*s);
 
   if (auto b = value.getAsBoolean())
     return std::make_shared<StructuredData::Boolean>(*b);
 
+  if (auto u = value.getAsUINT64())
+    return std::make_shared<StructuredData::Integer>(*u);
+
   if (auto i = value.getAsInteger())
     return std::make_shared<StructuredData::Integer>(*i);
 
   if (auto d = value.getAsNumber())
     return std::make_shared<StructuredData::Float>(*d);
 
   if (auto n = value.getAsNull())
     return std::make_shared<StructuredData::Null>();

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

 """
 Test some SBStructuredData API.
 """
 
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
+import json
 
 class TestStructuredDataAPI(TestBase):
     NO_DEBUG_INFO_TESTCASE = True
 
     def test(self):
         self.structured_data_api_test()
 
     def structured_data_api_test(self):
         error = lldb.SBError()
         s = lldb.SBStream()
-        s.Print(
-            "{\"key_dict\":{\"key_string\":\"STRING\",\"key_int\":3,\"key_float\":2.99,\"key_bool\":true,\"key_array\":[\"23\",\"arr\"]}}")
+
+        dict_str = json.dumps(
+                {"key_dict":
+                 {"key_string":"STRING",
+                  "key_uint":0xffffffff00000000,
+                  "key_float":2.99,
+                  "key_bool":True,
+                  "key_array":["23","arr"]}})
+        s.Print(dict_str)
         example = lldb.SBStructuredData()
 
         # Check SetFromJSON API for dictionaries, integers, floating point
         # values, strings and arrays
         error = example.SetFromJSON(s)
         if not error.Success():
             self.fail("FAILED:   " + error.GetCString())
 
def structured_data_api_test(self):
 
         # Tests for dictionary data type
         self.dictionary_struct_test(example)
 
         # Tests for string data type
         self.string_struct_test(dict_struct)
 
         # Tests for integer data type
-        self.int_struct_test(dict_struct)
+        self.uint_struct_test(dict_struct)
 
         # Tests for floating point data type
         self.double_struct_test(dict_struct)
 
         # Tests for boolean data type
         self.bool_struct_test(dict_struct)
 
         # Tests for array data type
def string_struct_test(self, dict_struct):
         # (e.g. getting an integer from a string type structure)
         output = string_struct.GetIntegerValue()
         if output:
             self.fail(
                 "Valid integer value " +
                 str(output) +
                 " returned for a string object")
 
-    def int_struct_test(self, dict_struct):
-        # Check a valid SBStructuredData containing an 'integer' by
-        int_struct = lldb.SBStructuredData()
-        int_struct = dict_struct.GetValueForKey("key_int")
-        if not int_struct.IsValid():
+    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 not int_struct.GetType() == lldb.eStructuredDataTypeInteger:
-            self.fail("Wrong type returned: " + str(int_struct.GetType()))
+        if not uint_struct.GetType() == lldb.eStructuredDataTypeInteger:
+            self.fail("Wrong type returned: " + str(uint_struct.GetType()))
 
         # Check API returning 'integer' value
-        output = int_struct.GetIntegerValue()
-        if not output == 3:
+        output = uint_struct.GetIntegerValue()
+        if not output == 0xffffffff00000000:
             self.fail("wrong output: " + str(output))
 
         # Calling wrong API on a SBStructuredData
         # (e.g. getting a string value from an integer type structure)
-        output = int_struct.GetStringValue(25)
+        output = uint_struct.GetStringValue(25)
         if output:
             self.fail(
                 "Valid string " +
                 output +
                 " returned for an integer object")
 
     def double_struct_test(self, dict_struct):
         floating_point_struct = lldb.SBStructuredData()