fix: CoPilot noticed a few smaller mistakes

Author: MrIndeciso

docs/basics/pointers.md

@@ -47,7 +47,7 @@ print(data.next.unwrap().value)   # 99
 
 ### Safe Dereferencing
 
-Use `try_unwrap()` for null-safe pointer access. It returns `None` if the pointer is null (0):
+Use `try_unwrap()` for safe pointer access. It returns `None` if the pointer address is unresolvable (e.g., out of bounds):
 
 ```python
 class node_t(struct):

docs/basics/types.md

@@ -123,9 +123,9 @@ memory = bytearray(b"Hello\x00World\x00")
 lib = inflater(memory)
 
 s = lib.inflate(c_str, 0)
-print(s.value)  # "Hello"
+print(s.value)  # b"Hello"
 print(len(s))   # 5
-print(s[0])     # 72 (ord('H'))
+print(s[0])     # b"H"
 ```
 
 !!! info

docs/memory/resolvers.md

@@ -51,7 +51,7 @@ All resolvers implement these methods:
 |---|---|
 | `resolve(size, offset)` | Read `size` bytes starting at the resolved address + offset |
 | `resolve_address()` | Return the absolute address of this resolver |
-| `write(data)` | Write bytes at the resolved address |
+| `modify(size, index, value)` | Write `value` bytes at the resolved address + index |
 | `relative_from_own(offset, size)` | Create a child resolver at a relative offset |
 | `absolute_from_own(address)` | Create a child resolver at an absolute address |
 
@@ -73,8 +73,8 @@ class DebuggerResolver(Resolver):
     def resolve_address(self):
         return self._address
 
-    def write(self, data, offset=0):
-        self.debugger.write_memory(self._address + offset, data)
+    def modify(self, size, index, value):
+        self.debugger.write_memory(self._address + index, value)
 
     # ... implement relative_from_own, absolute_from_own
 ```

libdestruct/common/ptr/ptr.py

@@ -58,8 +58,9 @@ def __init__(self: ptr, resolver: Resolver, wrapper: type | None = None) -> None
         """
         super().__init__(resolver)
         self.wrapper = wrapper
-        self._cached_unwrap: obj | None = None
+        self._cached_unwrap: obj | bytes | None = None
         self._cache_valid: bool = False
+        self._cached_length: int | None = None
 
     def get(self: ptr) -> int:
         """Return the value of the pointer."""
@@ -82,14 +83,15 @@ def invalidate(self: ptr) -> None:
         """Clear the cached unwrap result."""
         self._cached_unwrap = None
         self._cache_valid = False
+        self._cached_length = None
 
-    def unwrap(self: ptr, length: int | None = None) -> obj:
+    def unwrap(self: ptr, length: int | None = None) -> obj | bytes:
         """Return the object pointed to by the pointer.
 
         Args:
             length: The length of the object in memory this points to.
         """
-        if self._cache_valid:
+        if self._cache_valid and self._cached_length == length:
             return self._cached_unwrap
 
         address = self.get()
@@ -105,15 +107,16 @@ def unwrap(self: ptr, length: int | None = None) -> obj:
 
         self._cached_unwrap = result
         self._cache_valid = True
+        self._cached_length = length
         return result
 
-    def try_unwrap(self: ptr, length: int | None = None) -> obj | None:
+    def try_unwrap(self: ptr, length: int | None = None) -> obj | bytes | None:
         """Return the object pointed to by the pointer, if it is valid.
 
         Args:
             length: The length of the object in memory this points to.
         """
-        if self._cache_valid:
+        if self._cache_valid and self._cached_length == length:
             return self._cached_unwrap
 
         address = self.get()

libdestruct/libdestruct.py

@@ -19,7 +19,7 @@
 def inflater(memory: Sequence, endianness: str = "little") -> Inflater:
     """Return a TypeInflater instance."""
     if not isinstance(memory, Sequence):
-        raise TypeError(f"memory must be a MutableSequence, not {type(memory).__name__}")
+        raise TypeError(f"memory must be a Sequence, not {type(memory).__name__}")
 
     return Inflater(memory, endianness=endianness)
 

test/scripts/types_unit_test.py

@@ -293,6 +293,20 @@ def test_cache_invalidated_on_set(self):
         p.value = 12  # now points to offset 12
         self.assertEqual(p.unwrap().value, 20)
 
+    def test_untyped_cache_different_lengths(self):
+        """Untyped ptr cache must differentiate by length parameter."""
+        memory = bytearray(8 + 4)
+        memory[0:8] = (8).to_bytes(8, "little")   # pointer to offset 8
+        memory[8:12] = b"\x01\x02\x03\x04"
+
+        p = ptr(MemoryResolver(memory, 0))
+
+        r1 = p.unwrap(length=1)
+        self.assertEqual(r1, b"\x01")
+
+        r2 = p.unwrap(length=3)
+        self.assertEqual(r2, b"\x01\x02\x03")
+
 
 class FloatTest(unittest.TestCase):
     """c_float and c_double types."""