Debugger: Report full sizes instead of the elide setup

More direct communication of the meaning. Use 'length' when talking
about things like string lengths, and 'size' for sizes in bytes.

Task-number:  QTCREATORBUG-30065
Change-Id: Ifed84a5dab4ed890973c1abf4d427655eb50a61a
Reviewed-by: David Schulz <david.schulz@qt.io>

6 files changed, 184 insertions, 188 deletions

diff --git a/share/qtcreator/debugger/creatortypes.py b/share/qtcreator/debugger/creatortypes.py
index 24c16ce009..ba5b53450b 100644
--- a/share/qtcreator/debugger/creatortypes.py
+++ b/share/qtcreator/debugger/creatortypes.py
@@ -204,7 +204,7 @@ def qdump__CPlusPlus__Internal__Value(d, value):
 
 def qdump__Utils__FilePath(d, value):
     data, path_len, scheme_len, host_len = d.split("{@QString}IHH", value)
-    elided, enc = d.encodeStringHelper(data, d.displayStringLimit)
+    length, enc = d.encodeStringHelper(data, d.displayStringLimit)
     # enc is concatenated  path + scheme + host
     if scheme_len:
         scheme_pos = path_len * 4
@@ -221,7 +221,7 @@ def qdump__Utils__FilePath(d, value):
         val += path_enc
     else:
         val = enc
-    d.putValue(val, "utf16", elided=elided)
+    d.putValue(val, "utf16", length=length)
     d.putPlainChildren(value)
 
 
diff --git a/share/qtcreator/debugger/dumper.py b/share/qtcreator/debugger/dumper.py
index 1fd42848d4..ad25ad2dbe 100644
--- a/share/qtcreator/debugger/dumper.py
+++ b/share/qtcreator/debugger/dumper.py
@@ -44,15 +44,15 @@ class ReportItem():
     subsequent better guesses during a putItem() run.
     """
 
-    def __init__(self, value=None, encoding=None, priority=-100, elided=None):
+    def __init__(self, value=None, encoding=None, priority=-100, length=None):
         self.value = value
         self.priority = priority
         self.encoding = encoding
-        self.elided = elided
+        self.length = length
 
     def __str__(self):
-        return 'Item(value: %s, encoding: %s, priority: %s, elided: %s)' \
-            % (self.value, self.encoding, self.priority, self.elided)
+        return 'Item(value: %s, encoding: %s, priority: %s, length: %s)' \
+            % (self.value, self.encoding, self.priority, self.length)
 
 
 class Timer():
@@ -349,8 +349,8 @@ class DumperBase():
                 else:
                     if self.currentValue.encoding is not None:
                         self.put('valueencoded="%s",' % self.currentValue.encoding)
-                    if self.currentValue.elided:
-                        self.put('valueelided="%s",' % self.currentValue.elided)
+                    if self.currentValue.length:
+                        self.put('valuelen="%s",' % self.currentValue.length)
                     self.put('value="%s",' % self.currentValue.value)
             except:
                 pass
@@ -376,7 +376,7 @@ class DumperBase():
                         b = bytes(bytearray.fromhex(value))
                         value = codecs.decode(b, 'utf-16')
                     self.put('"%s"' % value)
-                    if self.currentValue.elided:
+                    if self.currentValue.length:
                         self.put('...')
 
                 if self.currentType.value:
@@ -545,40 +545,40 @@ class DumperBase():
         # assume no Qt 3 support by default
         return False
 
-    # Clamps size to limit.
-    def computeLimit(self, size, limit):
+    # Clamps length to limit.
+    def computeLimit(self, length, limit=0):
         if limit == 0:
             limit = self.displayStringLimit
-        if limit is None or size <= limit:
-            return 0, size
-        return size, limit
+        if limit is None or length <= limit:
+            return length
+        return limit
 
     def vectorData(self, value):
         if self.qtVersion() >= 0x060000:
-            data, size, alloc = self.qArrayData(value)
+            data, length, alloc = self.qArrayData(value)
         elif self.qtVersion() >= 0x050000:
             vector_data_ptr = self.extractPointer(value)
             if self.ptrSize() == 4:
-                (ref, size, alloc, offset) = self.split('IIIp', vector_data_ptr)
+                (ref, length, alloc, offset) = self.split('IIIp', vector_data_ptr)
             else:
-                (ref, size, alloc, pad, offset) = self.split('IIIIp', vector_data_ptr)
+                (ref, length, alloc, pad, offset) = self.split('IIIIp', vector_data_ptr)
             alloc = alloc & 0x7ffffff
             data = vector_data_ptr + offset
         else:
             vector_data_ptr = self.extractPointer(value)
-            (ref, alloc, size) = self.split('III', vector_data_ptr)
+            (ref, alloc, length) = self.split('III', vector_data_ptr)
             data = vector_data_ptr + 16
-        self.check(0 <= size and size <= alloc and alloc <= 1000 * 1000 * 1000)
-        return data, size
+        self.check(0 <= length and length <= alloc and alloc <= 1000 * 1000 * 1000)
+        return data, length
 
     def qArrayData(self, value):
         if self.qtVersion() >= 0x60000:
-            dd, data, size = self.split('ppp', value)
+            dd, data, length = self.split('ppp', value)
             if dd:
                 _, _, alloc = self.split('iip', dd)
             else: # fromRawData
-                alloc = size
-            return data, size, alloc
+                alloc = length
+            return data, length, alloc
         return self.qArrayDataHelper(self.extractPointer(value))
 
     def qArrayDataHelper(self, array_data_ptr):
@@ -586,10 +586,10 @@ class DumperBase():
         if self.qtVersion() >= 0x050000:
             # QTypedArray:
             # - QtPrivate::RefCount ref
-            # - int size
+            # - int length
             # - uint alloc : 31, capacityReserved : 1
             # - qptrdiff offset
-            (ref, size, alloc, offset) = self.split('IIpp', array_data_ptr)
+            (ref, length, alloc, offset) = self.split('IIpp', array_data_ptr)
             alloc = alloc & 0x7ffffff
             data = array_data_ptr + offset
             if self.ptrSize() == 4:
@@ -599,43 +599,42 @@ class DumperBase():
         elif self.qtVersion() >= 0x040000:
             # Data:
             # - QBasicAtomicInt ref;
-            # - int alloc, size;
+            # - int alloc, length;
             # - [padding]
             # - char *data;
             if self.ptrSize() == 4:
-                (ref, alloc, size, data) = self.split('IIIp', array_data_ptr)
+                (ref, alloc, length, data) = self.split('IIIp', array_data_ptr)
             else:
-                (ref, alloc, size, pad, data) = self.split('IIIIp', array_data_ptr)
+                (ref, alloc, length, pad, data) = self.split('IIIIp', array_data_ptr)
         else:
             # Data:
             # - QShared count;
             # - QChar *unicode
             # - char *ascii
             # - uint len: 30
-            (dummy, dummy, dummy, size) = self.split('IIIp', array_data_ptr)
-            size = self.extractInt(array_data_ptr + 3 * self.ptrSize()) & 0x3ffffff
-            alloc = size  # pretend.
+            (dummy, dummy, dummy, length) = self.split('IIIp', array_data_ptr)
+            length = self.extractInt(array_data_ptr + 3 * self.ptrSize()) & 0x3ffffff
+            alloc = length  # pretend.
             data = self.extractPointer(array_data_ptr + self.ptrSize())
-        return data, size, alloc
+        return data, length, alloc
 
     def encodeStringHelper(self, value, limit):
-        data, size, alloc = self.qArrayData(value)
+        data, length, alloc = self.qArrayData(value)
         if alloc != 0:
-            self.check(0 <= size and size <= alloc and alloc <= 100 * 1000 * 1000)
-        elided, shown = self.computeLimit(2 * size, 2 * limit)
-        return elided, self.readMemory(data, shown)
+            self.check(0 <= length and length <= alloc and alloc <= 100 * 1000 * 1000)
+        shown = self.computeLimit(2 * length, 2 * limit)
+        return length, self.readMemory(data, shown)
 
     def encodeByteArrayHelper(self, value, limit):
-        data, size, alloc = self.qArrayData(value)
+        data, length, alloc = self.qArrayData(value)
         if alloc != 0:
-            self.check(0 <= size and size <= alloc and alloc <= 100 * 1000 * 1000)
-        elided, shown = self.computeLimit(size, limit)
-        return elided, self.readMemory(data, shown)
+            self.check(0 <= length and length <= alloc and alloc <= 100 * 1000 * 1000)
+        shown = self.computeLimit(length, limit)
+        return length, self.readMemory(data, shown)
 
-    def putCharArrayValue(self, data, size, charSize,
+    def putCharArrayValue(self, data, length, charSize,
                           displayFormat=DisplayFormat.Automatic):
-        bytelen = size * charSize
-        elided, shown = self.computeLimit(bytelen, self.displayStringLimit)
+        shown = self.computeLimit(length, self.displayStringLimit)
         mem = self.readMemory(data, shown)
         if charSize == 1:
             if displayFormat in (DisplayFormat.Latin1String, DisplayFormat.SeparateLatin1String):
@@ -650,13 +649,13 @@ class DumperBase():
             encodingType = 'ucs4'
             #childType = 'int'
 
-        self.putValue(mem, encodingType, elided=elided)
+        self.putValue(mem, encodingType, length=length)
 
         if displayFormat in (
                 DisplayFormat.SeparateLatin1String,
                 DisplayFormat.SeparateUtf8String,
                 DisplayFormat.Separate):
-            elided, shown = self.computeLimit(bytelen, 100000)
+            shown = self.computeLimit(length, 100000)
             self.putDisplay(encodingType + ':separate', self.readMemory(data, shown))
 
     def putCharArrayHelper(self, data, size, charType,
@@ -676,15 +675,15 @@ class DumperBase():
         return self.hexencode(bytes(self.readRawMemory(addr, size)))
 
     def encodeByteArray(self, value, limit=0):
-        elided, data = self.encodeByteArrayHelper(value, limit)
+        _, data = self.encodeByteArrayHelper(value, limit)
         return data
 
     def putByteArrayValue(self, value):
-        elided, data = self.encodeByteArrayHelper(value, self.displayStringLimit)
-        self.putValue(data, 'latin1', elided=elided)
+        length, data = self.encodeByteArrayHelper(value, self.displayStringLimit)
+        self.putValue(data, 'latin1', length=length)
 
     def encodeString(self, value, limit=0):
-        elided, data = self.encodeStringHelper(value, limit)
+        _, data = self.encodeStringHelper(value, limit)
         return data
 
     def encodedUtf16ToUtf8(self, s):
@@ -730,8 +729,8 @@ class DumperBase():
         return inner
 
     def putStringValue(self, value):
-        elided, data = self.encodeStringHelper(value, self.displayStringLimit)
-        self.putValue(data, 'utf16', elided=elided)
+        length, data = self.encodeStringHelper(value, self.displayStringLimit)
+        self.putValue(data, 'utf16', length=length)
 
     def putPtrItem(self, name, value):
         with SubItem(self, name):
@@ -900,12 +899,12 @@ class DumperBase():
         if not self.isInt(thing):
             raise RuntimeError('Expected an integral value, got %s' % type(thing))
 
-    def readToFirstZero(self, base, tsize, maximum):
+    def readToFirstZero(self, base, typesize, maximum):
         self.checkIntType(base)
-        self.checkIntType(tsize)
+        self.checkIntType(typesize)
         self.checkIntType(maximum)
 
-        code = self.packCode + (None, 'b', 'H', None, 'I')[tsize]
+        code = self.packCode + (None, 'b', 'H', None, 'I')[typesize]
         #blob = self.readRawMemory(base, 1)
         blob = bytes()
         while maximum > 1:
@@ -916,8 +915,8 @@ class DumperBase():
                 maximum = int(maximum / 2)
                 self.warn('REDUCING READING MAXIMUM TO %s' % maximum)
 
-        #DumperBase.warn('BASE: 0x%x TSIZE: %s MAX: %s' % (base, tsize, maximum))
-        for i in range(0, maximum, tsize):
+        #DumperBase.warn('BASE: 0x%x TSIZE: %s MAX: %s' % (base, typesize, maximum))
+        for i in range(0, maximum, typesize):
             t = struct.unpack_from(code, blob, i)[0]
             if t == 0:
                 return 0, i, self.hexencode(blob[:i])
@@ -925,9 +924,9 @@ class DumperBase():
         # Real end is unknown.
         return -1, maximum, self.hexencode(blob[:maximum])
 
-    def encodeCArray(self, p, tsize, limit):
-        elided, shown, blob = self.readToFirstZero(p, tsize, limit)
-        return elided, blob
+    def encodeCArray(self, p, typesize, limit):
+        length, shown, blob = self.readToFirstZero(p, typesize, limit)
+        return length, blob
 
     def putItemCount(self, count, maximum=1000000000):
         # This needs to override the default value, so don't use 'put' directly.
@@ -1043,12 +1042,12 @@ class DumperBase():
                 self.currentType.value = typish.name
             self.currentType.priority = priority
 
-    def putValue(self, value, encoding=None, priority=0, elided=None):
+    def putValue(self, value, encoding=None, priority=0, length=None):
         # Higher priority values override lower ones.
-        # elided = 0 indicates all data is available in value,
+        # length = None indicates all data is available in value,
         # otherwise it's the true length.
         if priority >= self.currentValue.priority:
-            self.currentValue = ReportItem(value, encoding, priority, elided)
+            self.currentValue = ReportItem(value, encoding, priority, length)
 
     def putSpecialValue(self, encoding, value='', children=None):
         self.putValue(value, encoding)
@@ -1226,13 +1225,13 @@ class DumperBase():
 
         return False
 
-    def putSimpleCharArray(self, base, size=None):
-        if size is None:
-            elided, shown, data = self.readToFirstZero(base, 1, self.displayStringLimit)
+    def putSimpleCharArray(self, base, length=None):
+        if length is None:
+            length, shown, data = self.readToFirstZero(base, 1, self.displayStringLimit)
         else:
-            elided, shown = self.computeLimit(int(size), self.displayStringLimit)
+            shown = self.computeLimit(length)
             data = self.readMemory(base, shown)
-        self.putValue(data, 'latin1', elided=elided)
+        self.putValue(data, 'latin1', length=length)
 
     def putDisplay(self, editFormat, value):
         self.putField('editformat', editFormat)
@@ -1248,8 +1247,8 @@ class DumperBase():
             if targetType.name in ('char', 'signed char', 'unsigned char', 'uint8_t', 'CHAR'):
                 # Use UTF-8 as default for char *.
                 self.putType(typeName)
-                (elided, shown, data) = self.readToFirstZero(ptr, 1, limit)
-                self.putValue(data, 'utf8', elided=elided)
+                (length, shown, data) = self.readToFirstZero(ptr, 1, limit)
+                self.putValue(data, 'utf8', length=length)
                 if self.isExpanded():
                     self.putArrayData(ptr, shown, innerType)
                 return True
@@ -1257,55 +1256,55 @@ class DumperBase():
             if targetType.name in ('wchar_t', 'WCHAR'):
                 self.putType(typeName)
                 charSize = self.lookupType('wchar_t').size()
-                (elided, data) = self.encodeCArray(ptr, charSize, limit)
+                (length, data) = self.encodeCArray(ptr, charSize, limit)
                 if charSize == 2:
-                    self.putValue(data, 'utf16', elided=elided)
+                    self.putValue(data, 'utf16', length=length)
                 else:
-                    self.putValue(data, 'ucs4', elided=elided)
+                    self.putValue(data, 'ucs4', length=length)
                 return True
 
         if displayFormat == DisplayFormat.Latin1String:
             self.putType(typeName)
-            (elided, data) = self.encodeCArray(ptr, 1, limit)
-            self.putValue(data, 'latin1', elided=elided)
+            (length, data) = self.encodeCArray(ptr, 1, limit)
+            self.putValue(data, 'latin1', length=length)
             return True
 
         if displayFormat == DisplayFormat.SeparateLatin1String:
             self.putType(typeName)
-            (elided, data) = self.encodeCArray(ptr, 1, limit)
-            self.putValue(data, 'latin1', elided=elided)
+            (length, data) = self.encodeCArray(ptr, 1, limit)
+            self.putValue(data, 'latin1', length=length)
             self.putDisplay('latin1:separate', data)
             return True
 
         if displayFormat == DisplayFormat.Utf8String:
             self.putType(typeName)
-            (elided, data) = self.encodeCArray(ptr, 1, limit)
-            self.putValue(data, 'utf8', elided=elided)
+            (length, data) = self.encodeCArray(ptr, 1, limit)
+            self.putValue(data, 'utf8', length=length)
             return True
 
         if displayFormat == DisplayFormat.SeparateUtf8String:
             self.putType(typeName)
-            (elided, data) = self.encodeCArray(ptr, 1, limit)
-            self.putValue(data, 'utf8', elided=elided)
+            (length, data) = self.encodeCArray(ptr, 1, limit)
+            self.putValue(data, 'utf8', length=length)
             self.putDisplay('utf8:separate', data)
             return True
 
         if displayFormat == DisplayFormat.Local8BitString:
             self.putType(typeName)
-            (elided, data) = self.encodeCArray(ptr, 1, limit)
-            self.putValue(data, 'local8bit', elided=elided)
+            (length, data) = self.encodeCArray(ptr, 1, limit)
+            self.putValue(data, 'local8bit', length=length)
             return True
 
         if displayFormat == DisplayFormat.Utf16String:
             self.putType(typeName)
-            (elided, data) = self.encodeCArray(ptr, 2, limit)
-            self.putValue(data, 'utf16', elided=elided)
+            (length, data) = self.encodeCArray(ptr, 2, limit)
+            self.putValue(data, 'utf16', length=length)
             return True
 
         if displayFormat == DisplayFormat.Ucs4String:
             self.putType(typeName)
-            (elided, data) = self.encodeCArray(ptr, 4, limit)
-            self.putValue(data, 'ucs4', elided=elided)
+            (length, data) = self.encodeCArray(ptr, 4, limit)
+            self.putValue(data, 'ucs4', length=length)
             return True
 
         return False
@@ -2577,17 +2576,17 @@ class DumperBase():
 
     def extractQStringFromQDataStream(self, buf, offset):
         """ Read a QString from the stream """
-        size = struct.unpack_from('!I', buf, offset)[0]
+        length = struct.unpack_from('!I', buf, offset)[0]
         offset += 4
-        string = buf[offset:offset + size].decode('utf-16be')
-        return (string, offset + size)
+        string = buf[offset:offset + length].decode('utf-16be')
+        return (string, offset + length)
 
     def extractQByteArrayFromQDataStream(self, buf, offset):
         """ Read a QByteArray from the stream """
-        size = struct.unpack_from('!I', buf, offset)[0]
+        length = struct.unpack_from('!I', buf, offset)[0]
         offset += 4
-        string = buf[offset:offset + size].decode('latin1')
-        return (string, offset + size)
+        string = buf[offset:offset + length].decode('latin1')
+        return (string, offset + length)
 
     def extractIntFromQDataStream(self, buf, offset):
         """ Read an int from the stream """
diff --git a/share/qtcreator/debugger/qttypes.py b/share/qtcreator/debugger/qttypes.py
index b08f60a9bb..06e7d47325 100644
--- a/share/qtcreator/debugger/qttypes.py
+++ b/share/qtcreator/debugger/qttypes.py
@@ -28,46 +28,46 @@ def qform__QByteArray():
 
 def qedit__QByteArray(d, value, data):
     d.call('void', value, 'resize', str(len(data)))
-    (base, size, alloc) = d.stringData(value)
+    (base, length, alloc) = d.stringData(value)
     d.setValues(base, 'char', [ord(c) for c in data])
 
 
 def qdump__QByteArray(d, value):
     if d.qtVersion() >= 0x60000:
-        dd, data, size = value.split('ppi')
+        dd, data, length = value.split('ppi')
         if dd:
             _, _, alloc = d.split('iii', dd)
         else: # fromRawData
-            alloc = size
+            alloc = length
     else:
-        data, size, alloc = d.qArrayData(value)
+        data, length, alloc = d.qArrayData(value)
 
-    d.check(alloc == 0 or (0 <= size and size <= alloc and alloc <= 100000000))
-    if size > 0:
+    d.check(alloc == 0 or (0 <= length and length <= alloc and alloc <= 100000000))
+    if length > 0:
         d.putExpandable()
 
-    elided, shown = d.computeLimit(size, d.displayStringLimit)
+    shown = d.computeLimit(length, d.displayStringLimit)
     p = d.readMemory(data, shown)
 
     displayFormat = d.currentItemFormat()
     if displayFormat == DisplayFormat.Automatic or displayFormat == DisplayFormat.Latin1String:
-        d.putValue(p, 'latin1', elided=elided)
+        d.putValue(p, 'latin1', length=length)
     elif displayFormat == DisplayFormat.SeparateLatin1String:
-        d.putValue(p, 'latin1', elided=elided)
+        d.putValue(p, 'latin1', length=length)
         d.putDisplay('latin1:separate', d.encodeByteArray(value, limit=100000))
     elif displayFormat == DisplayFormat.Utf8String:
-        d.putValue(p, 'utf8', elided=elided)
+        d.putValue(p, 'utf8', length=length)
     elif displayFormat == DisplayFormat.SeparateUtf8String:
-        d.putValue(p, 'utf8', elided=elided)
+        d.putValue(p, 'utf8', length=length)
         d.putDisplay('utf8:separate', d.encodeByteArray(value, limit=100000))
     if d.isExpanded():
-        d.putArrayData(data, size, d.charType())
+        d.putArrayData(data, length, d.charType())
 
 
 #def qdump__QArrayData(d, value):
-#    data, size, alloc = d.qArrayDataHelper(value.address())
-#    d.check(alloc == 0 or (0 <= size and size <= alloc and alloc <= 100000000))
-#    d.putValue(d.readMemory(data, size), 'latin1')
+#    data, length, alloc = d.qArrayDataHelper(value.address())
+#    d.check(alloc == 0 or (0 <= length and length <= alloc and alloc <= 100000000))
+#    d.putValue(d.readMemory(data, length), 'latin1')
 #    d.putPlainChildren(value)
 
 
@@ -81,10 +81,10 @@ def qdump__QBitArray(d, value):
     else:
         data, basize, _ = d.qArrayData(value['d'])
     unused = d.extractByte(data) if data else 0
-    size = basize * 8 - unused
-    d.putItemCount(size)
+    length = basize * 8 - unused
+    d.putItemCount(length)
     if d.isExpanded():
-        with Children(d, size, maxNumChild=10000):
+        with Children(d, length, maxNumChild=10000):
             for i in d.childRange():
                 q = data + 1 + int(i / 8)
                 with SubItem(d, i):
@@ -1621,17 +1621,17 @@ def qdumpHelper_QSet45(d, value):
 
     ptrSize = d.ptrSize()
     dptr = d.extractPointer(value)
-    (fakeNext, buckets, ref, size, nodeSize, userNumBits, numBits, numBuckets) = \
+    (fakeNext, buckets, ref, length, nodeSize, userNumBits, numBits, numBuckets) = \
         d.split('ppiiihhi', dptr)
 
-    d.check(0 <= size and size <= 100 * 1000 * 1000)
+    d.check(0 <= length and length <= 100 * 1000 * 1000)
     d.check(-1 <= ref and ref < 100000)
 
-    d.putItemCount(size)
+    d.putItemCount(length)
     if d.isExpanded():
         keyType = value.type[0]
         isShort = d.qtVersion() < 0x050000 and keyType.name == 'int'
-        with Children(d, size, childType=keyType):
+        with Children(d, length, childType=keyType):
             node = hashDataFirstNode()
             for i in d.childRange():
                 if isShort:
@@ -1714,15 +1714,15 @@ def qdump__QStack(d, value):
 
 
 def qdump__QPolygonF(d, value):
-    data, size = d.vectorData(value)
-    d.putItemCount(size)
-    d.putPlotData(data, size, d.createType('@QPointF'))
+    data, length = d.vectorData(value)
+    d.putItemCount(length)
+    d.putPlotData(data, length, d.createType('@QPointF'))
 
 
 def qdump__QPolygon(d, value):
-    data, size = d.vectorData(value)
-    d.putItemCount(size)
-    d.putPlotData(data, size, d.createType('@QPoint'))
+    data, length = d.vectorData(value)
+    d.putItemCount(length)
+    d.putPlotData(data, length, d.createType('@QPoint'))
 
 
 def qdump__QGraphicsPolygonItem(d, value):
@@ -1741,14 +1741,14 @@ def qdump__QGraphicsPolygonItem(d, value):
             offset = 328 if d.isMsvcTarget() else 320
         else:
             offset = 308
-    data, size = d.vectorData(dptr + offset)
-    d.putItemCount(size)
-    d.putPlotData(data, size, d.createType('@QPointF'))
+    data, length = d.vectorData(dptr + offset)
+    d.putItemCount(length)
+    d.putPlotData(data, length, d.createType('@QPointF'))
 
 
 def qedit__QString(d, value, data):
     d.call('void', value, 'resize', str(len(data)))
-    (base, size, alloc) = d.stringData(value)
+    (base, length, alloc) = d.stringData(value)
     d.setValues(base, 'short', [ord(c) for c in data])
 
 
@@ -1758,14 +1758,14 @@ def qform__QString():
 
 def qdump__QString(d, value):
     d.putStringValue(value)
-    data, size, _ = d.stringData(value)
+    data, length, _ = d.stringData(value)
     displayFormat = d.currentItemFormat()
     if displayFormat == DisplayFormat.Separate:
         d.putDisplay('utf16:separate', d.encodeString(value, limit=100000))
-    if (size > 0):
+    if (length > 0):
         d.putExpandable()
         if d.isExpanded():
-            d.putArrayData(data, size, d.createType('@QChar'))
+            d.putArrayData(data, length, d.createType('@QChar'))
 
 
 def qdump__QSettingsKey(d, value):
@@ -1774,8 +1774,8 @@ def qdump__QSettingsKey(d, value):
 
 
 def qdump__QStaticStringData(d, value):
-    size = value.type[0]
-    (ref, size, alloc, pad, offset, data) = value.split('iii@p%ss' % (2 * size))
+    length = value.type[0]
+    (ref, length, alloc, pad, offset, data) = value.split('iii@p%ss' % (2 * length))
     d.putValue(d.hexencode(data), 'utf16')
     d.putPlainChildren(value)
 
@@ -1788,28 +1788,28 @@ def qdump__QTypedArrayData(d, value):
 
 
 def qdump__QStringData(d, value):
-    (ref, size, alloc, pad, offset) = value.split('III@p')
-    elided, shown = d.computeLimit(size, d.displayStringLimit)
+    (ref, length, alloc, pad, offset) = value.split('III@p')
+    shown = d.computeLimit(length, d.displayStringLimit)
     data = d.readMemory(value.address() + offset, shown * 2)
-    d.putValue(data, 'utf16', elided=elided)
+    d.putValue(data, 'utf16', length=length)
     d.putPlainChildren(value)
 
 
 def qdump__QAnyStringView(d, value):
-    data, size = value.split('pp')
+    data, length = value.split('pp')
     bits = d.ptrSize() * 8 - 2
-    tag = size >> bits
-    size = size & (2**bits - 1)
-    elided, shown = d.computeLimit(size, d.displayStringLimit)
+    tag = length >> bits
+    length = length & (2**bits - 1)
+    shown = d.computeLimit(length, d.displayStringLimit)
     if tag == 0:
         mem = d.readMemory(data, shown)
-        d.putValue(mem, 'utf8', elided=elided)
+        d.putValue(mem, 'utf8', length=length)
     elif tag == 1:
         mem = d.readMemory(data, shown)
-        d.putValue(mem, 'latin1', elided=elided)
+        d.putValue(mem, 'latin1', length=length)
     elif tag == 2:
         mem = d.readMemory(data, shown * 2)
-        d.putValue(mem, 'utf16', elided=elided)
+        d.putValue(mem, 'utf16', length=length)
     else:
         d.putSpecialValue('empty')
     d.putPlainChildren(value)
@@ -1825,16 +1825,15 @@ def qdump__QStringView(d, value):
     if idata == 0:
         d.putValue('(null)')
         return
-    size = value['m_size']
-    isize = size.integer()
-    elided, shown = d.computeLimit(isize, d.displayStringLimit)
+    length = value['m_size'].integer()
+    shown = d.computeLimit(length, d.displayStringLimit)
     mem = d.readMemory(idata, shown * 2)
-    d.putValue(mem, 'utf16', elided=elided)
+    d.putValue(mem, 'utf16', length=length)
     if d.currentItemFormat() == DisplayFormat.Separate:
         d.putDisplay('utf16:separate', mem)
     d.putExpandable()
     if d.isExpanded():
-        d.putArrayData(idata, isize, d.createType('char16_t'))
+        d.putArrayData(idata, length, d.createType('char16_t'))
 
 
 def qdump__QHashedString(d, value):
@@ -1848,12 +1847,12 @@ def qdump__QQmlRefCount(d, value):
 
 
 def qdump__QStringRef(d, value):
-    (stringptr, pos, size) = value.split('pii')
+    (stringptr, pos, length) = value.split('pii')
     if stringptr == 0:
         d.putValue('(null)')
         return
     data, ssize, alloc = d.stringData(d.createValue(stringptr, '@QString'))
-    d.putValue(d.readMemory(data + 2 * pos,  2 * size), 'utf16')
+    d.putValue(d.readMemory(data + 2 * pos,  2 * length), 'utf16')
     d.putPlainChildren(value)
 
 
@@ -1937,7 +1936,7 @@ def qdump__QUrl(d, value):
 
     userNameEnc = d.encodeString(userName)
     hostEnc = d.encodeString(host)
-    elided, pathEnc = d.encodeStringHelper(path, d.displayStringLimit)
+    length, pathEnc = d.encodeStringHelper(path, d.displayStringLimit)
     url = d.encodeString(scheme)
     url += '3a002f002f00'  # '://'
     if len(userNameEnc):
@@ -1946,7 +1945,7 @@ def qdump__QUrl(d, value):
     if port >= 0:
         url += '3a00' + ''.join(['%02x00' % ord(c) for c in str(port)])
     url += pathEnc
-    d.putValue(url, 'utf16', elided=elided)
+    d.putValue(url, 'utf16', length=length)
 
     displayFormat = d.currentItemFormat()
     if displayFormat == DisplayFormat.Separate:
@@ -2162,7 +2161,7 @@ def qdumpHelper__QVariant6(d, value):
         qdumpHelper_QVariant_0(d, value)
         return
 
-    revision, alignment, size, flags, variantType, metaObjectPtr, name = \
+    revision, alignment, length, flags, variantType, metaObjectPtr, name = \
         d.split('HHIIIpp', metaTypeInterface)
 
     # Well-known simple type.
@@ -2241,7 +2240,7 @@ def qdumpHelper__QVariant45(d, value):
             base1 = d.extractPointer(value)
             #DumperBase.warn('BASE 1: %s %s' % (base1, innert))
             base = d.extractPointer(base1)
-            #DumperBase.warn('SIZE 1: %s' % size)
+            #DumperBase.warn('SIZE 1: %s' % length)
             val = d.createValue(base, innerType)
         else:
             #DumperBase.warn('DIRECT ITEM 1: %s' % innerType)
@@ -2268,7 +2267,7 @@ def qdumpHelper__QVariant45(d, value):
                 d.putSpecialValue('notcallable')
                 return None
             ptr = p.pointer()
-            (elided, blob) = d.encodeCArray(ptr, 1, 100)
+            (_, blob) = d.encodeCArray(ptr, 1, 100)
             innerType = d.hexdecode(blob)
 
             # Prefer namespaced version.
@@ -2303,34 +2302,34 @@ def qform__QVector():
 
 def qdump__QVector(d, value):
     if d.qtVersion() >= 0x060000:
-        data, size = d.listData(value)
-        d.putItemCount(size)
-        d.putPlotData(data, size, d.createType(value.type.ltarget[0]))
+        data, length = d.listData(value)
+        d.putItemCount(length)
+        d.putPlotData(data, length, d.createType(value.type.ltarget[0]))
         # g++ 9.3 does not add the template parameter list to the debug info.
         # Fake it for the common case:
         if value.type.name == d.qtNamespace() + "QVector":
             d.putBetterType(value.type.name + '<' + value.type.ltarget[0].name + '>')
     else:
-        data, size = d.vectorData(value)
-        d.putItemCount(size)
-        d.putPlotData(data, size, d.createType(value.type[0]))
+        data, length = d.vectorData(value)
+        d.putItemCount(length)
+        d.putPlotData(data, length, d.createType(value.type[0]))
 
 
 if False:
     def qdump__QObjectConnectionList(d, value):
-        data, size = d.vectorData(value)
-        d.putItemCount(size)
-        d.putPlotData(data, size, d.createType('@QObjectPrivate::ConnectionList'))
+        data, length = d.vectorData(value)
+        d.putItemCount(length)
+        d.putPlotData(data, length, d.createType('@QObjectPrivate::ConnectionList'))
 
 
 def qdump__QVarLengthArray(d, value):
     if d.qtVersion() >= 0x060000:
-        cap, size, data = value.split('QQp')
+        cap, length, data = value.split('QQp')
     else:
-        cap, size, data = value.split('iip')
-    d.check(0 <= size)
-    d.putItemCount(size)
-    d.putPlotData(data, size, value.type[0])
+        cap, length, data = value.split('iip')
+    d.check(0 <= length)
+    d.putItemCount(length)
+    d.putPlotData(data, length, value.type[0])
 
 
 def qdump__QSharedPointer(d, value):
@@ -2401,20 +2400,20 @@ def qdump__QXmlAttributes(d, value):
 
 def qdump__QXmlStreamStringRef(d, value):
     s = value['m_string']
-    (data, size, alloc) = d.stringData(s)
+    (data, length, alloc) = d.stringData(s)
     data += 2 * int(value['m_position'])
-    size = int(value['m_size'])
-    s = d.readMemory(data, 2 * size)
+    length = int(value['m_size'])
+    s = d.readMemory(data, 2 * length)
     d.putValue(s, 'utf16')
     d.putPlainChildren(value)
 
 
 def qdump__QXmlStreamAttribute(d, value):
     s = value['m_name']['m_string']
-    (data, size, alloc) = d.stringData(s)
+    (data, length, alloc) = d.stringData(s)
     data += 2 * int(value['m_name']['m_position'])
-    size = int(value['m_name']['m_size'])
-    s = d.readMemory(data, 2 * size)
+    length = int(value['m_name']['m_size'])
+    s = d.readMemory(data, 2 * length)
     d.putValue(s, 'utf16')
     d.putPlainChildren(value)
 
@@ -2505,8 +2504,8 @@ def qdump__QV4__ExecutionContext(d, value):
 
 def qdump__QQmlSourceLocation(d, value):
     (sourceFile, line, col) = value.split('pHH')
-    (data, size, alloc) = d.stringData(value)
-    d.putValue(d.readMemory(data, 2 * size), 'utf16')
+    (data, length, alloc) = d.stringData(value)
+    d.putValue(d.readMemory(data, 2 * length), 'utf16')
     d.putField('valuesuffix', ':%s:%s' % (line, col))
     d.putPlainChildren(value)
 
@@ -3345,9 +3344,7 @@ def qdump__QJsonValue(d, value):
         return
     if t == 3:
         d.putType('QJsonValue (String)')
-        string = value.split('{@QString}')[0]
-        elided, base = d.encodeString(string, d.displayStringLimit)
-        d.putValue(base, 'utf16', elided=elided)
+        d.putStringValue(value.split('{@QString}')[0])
         return
     if t == 4:
         d.putType('QJsonValue (Array)')
@@ -3472,9 +3469,9 @@ def qdumpHelper_QCbor_string(d, container_ptr, element_index, is_bytes):
         bytedata_len = d.extractInt(bytedata)
         bytedata_data = bytedata + 4 # sizeof(QtCbor::ByteData) header part
 
-    elided, shown = d.computeLimit(bytedata_len, d.displayStringLimit)
+    shown = d.computeLimit(bytedata_len, d.displayStringLimit)
     res = d.readMemory(bytedata_data, shown)
-    d.putValue(res, enc, elided=elided)
+    d.putValue(res, enc, length=bytedata_len)
 
 
 def qdumpHelper_QCborArray_valueAt(d, container_ptr, elements_data_ptr, idx, bytedata, is_cbor):
diff --git a/src/plugins/debugger/watchdata.cpp b/src/plugins/debugger/watchdata.cpp
index 8d0af0e4d3..120ce75612 100644
--- a/src/plugins/debugger/watchdata.cpp
+++ b/src/plugins/debugger/watchdata.cpp
@@ -151,8 +151,8 @@ QString WatchItem::toString() const
     if (!value.isEmpty())
         str << "value=\"" << value << doubleQuoteComma;
 
-    if (elided)
-        str << "valueelided=\"" << elided << doubleQuoteComma;
+    if (valuelen)
+        str << "valuelen=\"" << valuelen << doubleQuoteComma;
 
     if (!editvalue.isEmpty())
         str << "editvalue=\"<...>\",";
@@ -300,9 +300,9 @@ void WatchItem::parseHelper(const GdbMi &input, bool maySort)
     if (mi.isValid())
         id = mi.toInt();
 
-    mi = input["valueelided"];
+    mi = input["valuelen"];
     if (mi.isValid())
-        elided = mi.toInt();
+        valuelen = mi.toInt();
 
     mi = input["bitpos"];
     if (mi.isValid())
diff --git a/src/plugins/debugger/watchdata.h b/src/plugins/debugger/watchdata.h
index bb2e458bcd..672ded5e7c 100644
--- a/src/plugins/debugger/watchdata.h
+++ b/src/plugins/debugger/watchdata.h
@@ -72,7 +72,7 @@ public:
     uint            bitsize = 0;           // Size in case of bit fields
     uint            autoDerefCount = 0;    // number of levels of automatic dereferencing that has taken place (for pointer types)
     uint            variablesReference = 0;// reference to the variable in the variables request DAP related
-    int             elided = 0;            // Full size if value was cut off, -1 if cut on unknown size, 0 otherwise
+    int             valuelen = 0;          // -1 if cut on unknown size, full size otherwise
     int             arrayIndex = -1;       // -1 if not an array member
     uchar           sortGroup = 0;         // 0 - ordinary member, 1 - vptr, 2 - base class
     bool            wantsChildren = false;
diff --git a/src/plugins/debugger/watchhandler.cpp b/src/plugins/debugger/watchhandler.cpp
index 651c86bf2d..841dc4d015 100644
--- a/src/plugins/debugger/watchhandler.cpp
+++ b/src/plugins/debugger/watchhandler.cpp
@@ -822,12 +822,12 @@ static QString formattedValue(const WatchItem *item)
     QString v = quoteUnprintable(item->value);
 
     if (v.endsWith('"')) {
-        if (item->elided) {
+        if (item->valuelen > maxLength) {
             v.chop(1);
             v.append("...\"");
         }
-        int len = item->elided ? item->elided : item->value.length() - 2;
-        v += QString(" (%1)").arg(len > 0 ? QString::number(len) : "unknown length");
+        if (item->valuelen > 0)
+            v += QString(" (%1)").arg(item->valuelen);
         return v;
     }
 
@@ -1297,7 +1297,7 @@ Qt::ItemFlags WatchModel::flags(const QModelIndex &idx) const
             // FIXME: Forcing types is not implemented yet.
             //if (idx.column() == 2)
             //    return editable; // Watcher types can be set by force.
-            if (column == ValueColumn && item->valueEditable && !item->elided)
+            if (column == ValueColumn && item->valueEditable && item->valuelen >= 0)
                 return editable; // Watcher values are sometimes editable.
         }
     } else if (item->isLocal()) {
@@ -1305,7 +1305,7 @@ Qt::ItemFlags WatchModel::flags(const QModelIndex &idx) const
             return notEditable;
         if (isRunning && !m_engine->hasCapability(AddWatcherWhileRunningCapability))
             return notEditable;
-        if (column == ValueColumn && item->valueEditable && !item->elided)
+        if (column == ValueColumn && item->valueEditable && item->valuelen >= 0)
             return editable; // Locals values are sometimes editable.
         if (column == ValueColumn && item->arrayIndex >= 0)
             return editable;