fix: correct various problems in the codebase

MrIndeciso · MrIndeciso · commit 60ebfe0414f0 · 2026-03-31T16:18:10.000-05:00
diff --git a/libdestruct/__init__.py b/libdestruct/__init__.py
@@ -11,11 +11,12 @@
 except ImportError:  # pragma: no cover
     pass
 
+from libdestruct.backing.resolver import Resolver
 from libdestruct.c import c_int, c_long, c_str, c_uint, c_ulong
 from libdestruct.common.array import array, array_of
 from libdestruct.common.attributes import offset
 from libdestruct.common.enum import enum, enum_of
-from libdestruct.common.ptr import ptr
+from libdestruct.common.ptr.ptr import ptr
 from libdestruct.common.struct import ptr_to, ptr_to_self, struct
 from libdestruct.libdestruct import inflate, inflater
 
@@ -35,5 +36,6 @@
     "ptr",
     "ptr_to",
     "ptr_to_self",
+    "Resolver",
     "struct",
 ]
diff --git a/libdestruct/backing/fake_resolver.py b/libdestruct/backing/fake_resolver.py
@@ -12,7 +12,7 @@
 class FakeResolver(Resolver):
     """A class that can resolve elements in a simulated memory storage."""
 
-    def __init__(self: FakeResolver, memory: dict | None = None, address: int | None = 0) -> FakeResolver:
+    def __init__(self: FakeResolver, memory: dict | None = None, address: int | None = 0) -> None:
         """Initializes a basic fake resolver."""
         self.memory = memory if memory is not None else {}
         self.address = address
@@ -47,7 +47,7 @@ def resolve(self: FakeResolver, size: int, _: int) -> bytes:
         result = b""
 
         while size:
-            page = self.memory.get(page_address, b"\x00" * (0x1000 - page_offset))
+            page = self.memory.get(page_address, b"\x00" * 0x1000)
             page_size = min(size, 0x1000 - page_offset)
             result += page[page_offset : page_offset + page_size]
             size -= page_size
diff --git a/libdestruct/backing/memory_resolver.py b/libdestruct/backing/memory_resolver.py
@@ -17,7 +17,7 @@
 class MemoryResolver(Resolver):
     """A class that can resolve itself to a value in a referenced memory storage."""
 
-    def __init__(self: MemoryResolver, memory: MutableSequence, address: int | None) -> MemoryResolver:
+    def __init__(self: MemoryResolver, memory: MutableSequence, address: int | None) -> None:
         """Initializes a basic memory resolver."""
         self.memory = memory
         self.address = address
@@ -38,7 +38,7 @@ def relative_from_own(self: MemoryResolver, address_offset: int, _: int) -> Memo
         new_resolver.offset = address_offset
         return new_resolver
 
-    def absolute_from_own(self: Resolver, address: int) -> MemoryResolver:
+    def absolute_from_own(self: MemoryResolver, address: int) -> MemoryResolver:
         """Creates a resolver that has an absolute reference to an object, from the parent's view."""
         return MemoryResolver(self.memory, address)
 
@@ -47,7 +47,7 @@ def resolve(self: MemoryResolver, size: int, _: int) -> bytes:
         address = self.resolve_address()
         return self.memory[address : address + size]
 
-    def modify(self: Resolver, size: int, _: int, value: bytes) -> None:
+    def modify(self: MemoryResolver, size: int, _: int, value: bytes) -> None:
         """Modifies itself in memory."""
         address = self.resolve_address()
         self.memory[address : address + size] = value
diff --git a/libdestruct/c/c_str.py b/libdestruct/c/c_str.py
@@ -32,7 +32,7 @@ def get(self: c_str, index: int = -1) -> bytes:
         if index == -1:
             return self.resolver.resolve(self.count(), 0)
 
-        return bytes([self.resolver.resolve(index)[-1]])
+        return bytes([self.resolver.resolve(index + 1, 0)[-1]])
 
     def to_bytes(self: c_str) -> bytes:
         """Return the serialized representation of the object."""
@@ -50,6 +50,10 @@ def _set(self: c_str, value: bytes, index: int = -1) -> None:
             prev = self.resolver.resolve(index, 0)
             self.resolver.modify(index + len(value), 0, prev + value)
 
+    def __setitem__(self: c_str, index: int, value: bytes) -> None:
+        """Set the character at the given index to the given value."""
+        self._set(value, index)
+
     def __iter__(self: c_str) -> iter:
         """Return an iterator over the string."""
         for i in range(self.count()):
diff --git a/libdestruct/c/ctypes_generic.py b/libdestruct/c/ctypes_generic.py
@@ -34,6 +34,6 @@ def _set(self: _ctypes_generic, value: Any) -> None:
     def to_bytes(self: _ctypes_generic) -> bytes:
         """Serialize the type to bytes."""
         if self._frozen:
-            return bytes(self._frozen_value)
+            return bytes(self.backing_type(self._frozen_value))
 
         return self.resolver.resolve(self.size, 0)
diff --git a/libdestruct/c/struct_parser.py b/libdestruct/c/struct_parser.py
@@ -96,6 +96,11 @@ def ptr_to_type(ptr: c_ast.PtrDecl, parent: c_ast.Struct | None = None) -> type[
     if not isinstance(ptr, c_ast.PtrDecl):
         raise TypeError("Definition must be a pointer.")
 
+    # Handle nested pointers (e.g., int **pp) by recursively wrapping in ptr_to
+    if isinstance(ptr.type, c_ast.PtrDecl):
+        inner = ptr_to_type(ptr.type, parent)
+        return ptr_to(inner)
+
     if not isinstance(ptr.type, c_ast.TypeDecl):
         raise TypeError("Definition must be a type declaration.")
 
diff --git a/libdestruct/common/__init__.py b/libdestruct/common/__init__.py
@@ -3,3 +3,5 @@
 # Copyright (c) 2024 Roberto Alessandro Bertolini. All rights reserved.
 # Licensed under the MIT license. See LICENSE file in the project root for details.
 #
+
+import libdestruct.common.forward_ref_inflater
diff --git a/libdestruct/common/array/array.py b/libdestruct/common/array/array.py
@@ -23,8 +23,8 @@ def __len__(self: array) -> int:
         return self.count()
 
     @abstractmethod
-    def get(self: array, index: int) -> object:
-        """Return the element at the given index."""
+    def get(self: array, index: int = -1) -> object:
+        """Return the element at the given index, or all elements if index is -1."""
 
     def __getitem__(self: array, index: int) -> object:
         """Return the element at the given index."""
diff --git a/libdestruct/common/array/array_impl.py b/libdestruct/common/array/array_impl.py
@@ -46,8 +46,10 @@ def count(self: array_impl) -> int:
         """Get the size of the array."""
         return self._count
 
-    def get(self: array, index: int) -> object:
-        """Return the element at the given index."""
+    def get(self: array, index: int = -1) -> object:
+        """Return the element at the given index, or all elements if index is -1."""
+        if index == -1:
+            return [self.backing_type(self.resolver.relative_from_own(i * self.item_size, 0)) for i in range(self._count)]
         return self.backing_type(self.resolver.relative_from_own(index * self.item_size, 0))
 
     def _set(self: array_impl, _: list[obj]) -> None:
diff --git a/libdestruct/common/enum/enum.py b/libdestruct/common/enum/enum.py
@@ -59,4 +59,4 @@ def to_bytes(self: enum) -> bytes:
 
     def to_str(self: obj, indent: int = 0) -> str:
         """Return a string representation of the object."""
-        return f"{' ' * indent}{self.get()!r}"
+        return f"{self.get()!r}"
diff --git a/libdestruct/common/forward_ref_inflater.py b/libdestruct/common/forward_ref_inflater.py
@@ -0,0 +1,133 @@
+#
+# This file is part of libdestruct (https://github.com/mrindeciso/libdestruct).
+# Copyright (c) 2025 Roberto Alessandro Bertolini. All rights reserved.
+# Licensed under the MIT license. See LICENSE file in the project root for details.
+#
+
+
+from __future__ import annotations
+
+import sys
+from typing import TYPE_CHECKING, ForwardRef
+
+from libdestruct.common.ptr.ptr import ptr
+from libdestruct.common.ptr.ptr_field import PtrField
+from libdestruct.common.type_registry import TypeRegistry
+
+if TYPE_CHECKING:  # pragma: no cover
+    from collections.abc import Callable
+
+    from libdestruct.backing.resolver import Resolver
+    from libdestruct.common.obj import obj
+
+
+registry = TypeRegistry()
+
+
+class _LazyPtrField(PtrField):
+    """A PtrField that lazily resolves a forward reference at inflation time."""
+
+    def __init__(self: _LazyPtrField, forward_ref: ForwardRef, owner: tuple[obj, type[obj]] | None) -> None:
+        super().__init__(None)
+        self.forward_ref = forward_ref
+        self.owner = owner
+
+    def inflate(self: _LazyPtrField, resolver: Resolver) -> obj:
+        """Inflate the field, resolving the forward reference on first use."""
+        if self.backing_type is None:
+            resolved = self._resolve_forward_ref()
+            if resolved is not None:
+                self.backing_type = registry.inflater_for(resolved)
+
+        if self.backing_type:
+            return ptr(resolver, self.backing_type)
+
+        return ptr(resolver)
+
+    def _resolve_forward_ref(self: _LazyPtrField) -> type | None:
+        """Resolve the forward reference to an actual type."""
+        globalns = {}
+        localns = {}
+
+        if self.owner:
+            _, owner_type = self.owner
+
+            # Get the user's reference struct for proper module resolution
+            ref_struct = getattr(owner_type, "_reference_struct", owner_type)
+
+            if hasattr(ref_struct, "__module__"):
+                module = sys.modules.get(ref_struct.__module__)
+                if module:
+                    globalns = module.__dict__
+
+            # Add the reference struct to locals for self-references
+            if hasattr(ref_struct, "__name__"):
+                localns[ref_struct.__name__] = ref_struct
+
+        try:
+            resolved = eval(self.forward_ref.__forward_arg__, globalns, localns)  # noqa: S307
+            if isinstance(resolved, type):
+                return resolved
+            return None
+        except Exception:
+            return None
+
+
+def _subscripted_ptr_handler(
+    item: object,
+    args: tuple,
+    owner: tuple[obj, type[obj]] | None,
+) -> Callable[[Resolver], obj] | None:
+    """Handle subscripted ptr types like ptr["Node"] or ptr[SomeType]."""
+    target = args[0] if args else None
+
+    if target is None:
+        field = PtrField(None)
+        return field.inflate
+
+    if isinstance(target, type):
+        field = PtrField(target)
+        field.backing_type = registry.inflater_for(target)
+        return field.inflate
+
+    # String or ForwardRef: use lazy resolution
+    if isinstance(target, str):
+        target = ForwardRef(target)
+
+    if isinstance(target, ForwardRef):
+        lazy_field = _LazyPtrField(target, owner)
+        return lazy_field.inflate
+
+    field = PtrField(None)
+    return field.inflate
+
+
+def _forward_ref_inflater(
+    forward_ref: ForwardRef,
+    _: type[obj],
+    owner: tuple[obj, type[obj]] | None,
+) -> Callable[[Resolver], obj]:
+    """Handle bare ForwardRef annotations that couldn't be resolved at annotation time."""
+    forward_arg = forward_ref.__forward_arg__
+
+    # Check if it's a ptr forward reference (e.g., from `from __future__ import annotations`
+    # where ptr wasn't in scope)
+    if forward_arg.startswith("ptr[") and forward_arg.endswith("]"):
+        inner_type = forward_arg[4:-1]
+        if (inner_type.startswith("'") and inner_type.endswith("'")) or (
+            inner_type.startswith('"') and inner_type.endswith('"')
+        ):
+            inner_type = inner_type[1:-1]
+
+        target_ref = ForwardRef(inner_type)
+        lazy_field = _LazyPtrField(target_ref, owner)
+        return lazy_field.inflate
+
+    raise ValueError(
+        f"Cannot resolve forward reference '{forward_arg}'. "
+        f"Ensure the type is imported and available in the module scope.",
+    )
+
+
+registry.register_generic_handler(ptr, _subscripted_ptr_handler)
+registry.register_instance_handler(ForwardRef, _forward_ref_inflater)
diff --git a/libdestruct/common/obj.py b/libdestruct/common/obj.py
@@ -7,13 +7,14 @@
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Generic, TypeVar
 
 if TYPE_CHECKING:  # pragma: no cover
     from libdestruct.backing.resolver import Resolver
 
+T = TypeVar("T")
 
-class obj(ABC):
+class obj(ABC, Generic[T]):
     """A generic object, with reference to the backing memory view."""
 
     endianness: str = "little"
@@ -56,7 +57,10 @@ def to_bytes(self: obj) -> bytes:
     @classmethod
     def from_bytes(cls: type[obj], data: bytes) -> obj:
         """Deserialize the object from bytes."""
-        item = cls(data, 0)
+        from libdestruct.libdestruct import inflater
+
+        lib = inflater(data)
+        item = lib.inflate(cls, 0)
         item.freeze()
         return item
 
diff --git a/libdestruct/common/ptr/ptr.py b/libdestruct/common/ptr/ptr.py
@@ -6,16 +6,17 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, TypeVar
 
 from libdestruct.common.field import Field
 from libdestruct.common.obj import obj
 
 if TYPE_CHECKING:  # pragma: no cover
     from libdestruct.backing.resolver import Resolver
 
+T = TypeVar("T")
 
-class ptr(obj):
+class ptr(obj[T]):
     """A pointer to an object in memory."""
 
     size: int = 8
@@ -76,7 +77,7 @@ def try_unwrap(self: ptr, length: int | None = None) -> obj | None:
 
         try:
             # If the address is invalid, this will raise an IndexError or ValueError.
-            self.resolver.absolute_from_own(address).resolve(length)
+            self.resolver.absolute_from_own(address).resolve(length or 1, 0)
         except (IndexError, ValueError):
             return None
 
diff --git a/libdestruct/common/struct/struct.py b/libdestruct/common/struct/struct.py
@@ -26,8 +26,8 @@ def __init__(self: struct) -> None:
     def __new__(cls: type[struct], *args: ..., **kwargs: ...) -> struct:  # noqa: PYI034
         """Create a new struct."""
         # Look for an inflater for this struct
-        inflater = TypeRegistry().inflater_for(cls)
-        return inflater(*args, **kwargs)
+        type_impl = TypeRegistry().inflater_for(cls)
+        return type_impl(*args, **kwargs)
 
     @classmethod
     def from_bytes(cls: type[struct], data: bytes) -> struct_impl:
diff --git a/libdestruct/common/struct/struct_impl.py b/libdestruct/common/struct/struct_impl.py
@@ -51,6 +51,17 @@ def __init__(self: struct_impl, resolver: Resolver | None = None, **kwargs: ...)
         for name, value in kwargs.items():
             getattr(self, name).value = value
 
+    def __getattribute__(self: struct_impl, name: str) -> object:
+        """Return the attribute, checking struct members first to avoid collisions with obj properties."""
+        # Check _members dict directly to avoid infinite recursion
+        try:
+            members = object.__getattribute__(self, "_members")
+            if name in members:
+                return members[name]
+        except AttributeError:
+            pass
+        return super().__getattribute__(name)
+
     def __new__(cls: struct_impl, *args: ..., **kwargs: ...) -> Self:
         """Create a new struct."""
         # Skip the __new__ method of the parent class
@@ -101,7 +112,6 @@ def _inflate_struct_attributes(
                 resolved_type = inflater.inflater_for(annotation, owner=(self, reference_type._type_impl))
 
             result = resolved_type(resolver.relative_from_own(current_offset, 0))
-            setattr(self, name, result)
             self._members[name] = result
             current_offset += size_of(result)
 
@@ -127,7 +137,7 @@ def compute_own_size(cls: type[struct_impl], reference_type: type) -> None:
 
                 for attr in attrs:
                     if isinstance(attr, Field):
-                        attribute = cls._inflater.inflater_for((attr, annotation))(None)
+                        attribute = cls._inflater.inflater_for((attr, annotation), (None, cls))(None)
                     elif isinstance(attr, OffsetAttribute):
                         offset = attr.offset
                         if offset < size:
@@ -138,11 +148,11 @@ def compute_own_size(cls: type[struct_impl], reference_type: type) -> None:
 
                 # If we don't have a Field, we need to inflate the attribute as if we have no attributes
                 if not attribute:
-                    attribute = cls._inflater.inflater_for(annotation)
+                    attribute = cls._inflater.inflater_for(annotation, (None, cls))
             elif isinstance(annotation, Field):
-                attribute = cls._inflater.inflater_for((annotation, annotation.base_type))(None)
+                attribute = cls._inflater.inflater_for((annotation, annotation.base_type), (None, cls))(None)
             else:
-                attribute = cls._inflater.inflater_for(annotation)
+                attribute = cls._inflater.inflater_for(annotation, (None, cls))
 
             size += size_of(attribute)
 
diff --git a/libdestruct/common/type_registry.py b/libdestruct/common/type_registry.py
diff --git a/libdestruct/common/utils.py b/libdestruct/common/utils.py
diff --git a/test/scripts/basic_struct_test.py b/test/scripts/basic_struct_test.py
diff --git a/test/scripts/regression_test.py b/test/scripts/regression_test.py

Original file line number	Diff line number	Diff line change
`@@ -3,3 +3,5 @@`
`3`	`3`	`# Copyright (c) 2024 Roberto Alessandro Bertolini. All rights reserved.`
`4`	`4`	`# Licensed under the MIT license. See LICENSE file in the project root for details.`
`5`	`5`	`#`
	`6`	`+`
	`7`	`+import libdestruct.common.forward_ref_inflater`