fix: various mistakes related to structs and obj hashing

Author: MrIndeciso

libdestruct/common/obj.py

@@ -145,6 +145,10 @@ def _compare_value(self: obj, other: object) -> tuple[object, object] | None:
             return self_val, other
         return None
 
+    # Restore identity hashing — Python blanks __hash__ when __eq__ is defined.
+    # Equality is value-based but hash is identity, so {a, b} won't dedupe equal values.
+    __hash__ = object.__hash__
+
     def __eq__(self: obj, other: object) -> bool:
         """Return whether the object is equal to the given value."""
         pair = self._compare_value(other)

libdestruct/common/struct/struct_impl.py

@@ -183,14 +183,18 @@ def _resolve_field(
             Either resolved_inflater or bitfield_field will be non-None (not both).
             explicit_offset is set when an OffsetAttribute is present.
         """
-        # Unwrap Annotated[type, metadata...] — extract the real type and any metadata
         annotated_offset = None
         if get_origin(annotation) is Annotated:
             ann_args = get_args(annotation)
             annotation = ann_args[0]
-            for meta in ann_args[1:]:
-                if isinstance(meta, OffsetAttribute):
-                    annotated_offset = meta.offset
+            ann_offsets = [m.offset for m in ann_args[1:] if isinstance(m, OffsetAttribute)]
+            if len(ann_offsets) > 1:
+                raise ValueError(
+                    f"Field {name!r} has multiple OffsetAttribute entries in its Annotated metadata; "
+                    f"only one is allowed.",
+                )
+            if ann_offsets:
+                annotated_offset = ann_offsets[0]
 
         if name not in reference.__dict__:
             return inflater.inflater_for(annotation, owner=owner), None, annotated_offset
@@ -202,6 +206,13 @@ def _resolve_field(
         if sum(isinstance(attr, Field) for attr in attrs) > 1:
             raise ValueError("Only one Field is allowed per attribute.")
 
+        attr_offsets = sum(isinstance(a, OffsetAttribute) for a in attrs)
+        if attr_offsets + (1 if annotated_offset is not None else 0) > 1:
+            raise ValueError(
+                f"Field {name!r} has multiple OffsetAttribute entries (across Annotated metadata "
+                f"and attribute tuple); only one is allowed.",
+            )
+
         resolved_type = None
         bitfield_field = None
         explicit_offset = annotated_offset
@@ -231,6 +242,7 @@ def compute_own_size(cls: type[struct_impl], reference_type: type) -> None:
         bf_tracker = BitfieldTracker()
         aligned = getattr(reference_type, "_aligned_", False)
         seen_vla = False
+        seen_names: set[str] = set()
 
         for name, annotation, reference in iterate_annotation_chain(reference_type, terminate_at=struct):
             if name == "_aligned_":
@@ -245,13 +257,24 @@ def compute_own_size(cls: type[struct_impl], reference_type: type) -> None:
             # Detect VLA from default value or subscript annotation
             default = getattr(reference, name, None) if hasattr(reference, name) else None
             is_vla = isinstance(default, VLAField)
-            if not is_vla and isinstance(annotation, GenericAlias):
+            count_field_name: str | None = None
+            if is_vla:
+                count_field_name = default.count_field
+            elif isinstance(annotation, GenericAlias):
                 args = annotation.__args__
                 if len(args) == 2 and isinstance(args[1], str):
                     is_vla = True
+                    count_field_name = args[1]
             if is_vla:
+                if count_field_name is not None and count_field_name not in seen_names:
+                    raise ValueError(
+                        f"VLA field {name!r} references undefined count field {count_field_name!r}. "
+                        f"The count field must be declared before the VLA in the same struct.",
+                    )
                 seen_vla = True
 
+            seen_names.add(name)
+
             resolved_type, bitfield_field, explicit_offset = struct_impl._resolve_field(
                 name, annotation, reference, cls._inflater, owner=(None, cls),
             )
@@ -351,13 +374,13 @@ def freeze(self: struct_impl) -> None:
         super().freeze()
 
     def reset(self: struct_impl) -> None:
-        """Reset each member to its frozen value."""
+        """Restore the struct's memory region to the bytes captured at freeze time."""
         if not object.__getattribute__(self, "_frozen"):
             raise RuntimeError("Cannot reset a struct that has not been frozen.")
 
-        members = object.__getattribute__(self, "_members")
-        for member in members.values():
-            member.reset()
+        resolver = object.__getattribute__(self, "resolver")
+        frozen_bytes = object.__getattribute__(self, "_frozen_struct_bytes")
+        resolver.modify(len(frozen_bytes), 0, frozen_bytes)
 
     def to_str(self: struct_impl, indent: int = 0) -> str:
         """Return a string representation of the struct."""
@@ -384,6 +407,8 @@ def __repr__(self: struct_impl) -> str:
     }}
 }}"""
 
+    __hash__ = object.__hash__
+
     def __eq__(self: struct_impl, value: object) -> bool:
         """Return whether the struct is equal to the given value."""
         if not isinstance(value, struct_impl):

test/scripts/struct_test.py

@@ -704,5 +704,91 @@ class s_t(struct):
         self.assertEqual(s.to_bytes(), memory)
 
 
+class StructResetWithCompositesTest(unittest.TestCase):
+    """struct.reset() must work for any composite member shape, including arrays."""
+
+    def test_reset_struct_with_array(self):
+        from libdestruct.backing.memory_resolver import MemoryResolver
+
+        class S(struct):
+            arr: array[c_int, 3]
+
+        memory = bytearray((1).to_bytes(4, "little") + (2).to_bytes(4, "little") + (3).to_bytes(4, "little"))
+        s = S(MemoryResolver(memory, 0))
+        s.freeze()
+        memory[0:4] = (99).to_bytes(4, "little")
+        memory[4:8] = (98).to_bytes(4, "little")
+        s.reset()
+        self.assertEqual(int.from_bytes(memory[0:4], "little"), 1)
+        self.assertEqual(int.from_bytes(memory[4:8], "little"), 2)
+
+    def test_reset_struct_with_nested_array_of_struct(self):
+        from libdestruct.backing.memory_resolver import MemoryResolver
+
+        class Inner(struct):
+            x: c_int
+
+        class Outer(struct):
+            items: array[Inner, 2]
+
+        memory = bytearray((10).to_bytes(4, "little") + (20).to_bytes(4, "little"))
+        s = Outer(MemoryResolver(memory, 0))
+        s.freeze()
+        memory[0:4] = (999).to_bytes(4, "little")
+        s.reset()
+        self.assertEqual(int.from_bytes(memory[0:4], "little"), 10)
+
+
+class AnnotatedMultipleOffsetTest(unittest.TestCase):
+    """Multiple OffsetAttribute on a single field must raise instead of silently using one."""
+
+    def test_two_offsets_in_annotated_raises(self):
+        from libdestruct.common.attributes.offset_attribute import OffsetAttribute
+        from libdestruct.backing.memory_resolver import MemoryResolver
+
+        class S(struct):
+            pad: c_int
+            field: Annotated[c_int, OffsetAttribute(4), OffsetAttribute(8)]
+
+        with self.assertRaises(ValueError):
+            S(MemoryResolver(bytearray(16), 0))
+
+    def test_offset_in_annotated_and_attribute_tuple_raises(self):
+        from libdestruct.common.attributes.offset_attribute import OffsetAttribute
+        from libdestruct.backing.memory_resolver import MemoryResolver
+
+        class S(struct):
+            pad: c_int
+            field: Annotated[c_int, OffsetAttribute(4)] = OffsetAttribute(8)
+
+        with self.assertRaises(ValueError):
+            S(MemoryResolver(bytearray(16), 0))
+
+
+class VLAUndefinedCountFieldTest(unittest.TestCase):
+    """VLA referencing a count field that doesn't exist must fail at struct definition (inflation)."""
+
+    def test_undefined_count_field_subscript_form(self):
+        from libdestruct.backing.memory_resolver import MemoryResolver
+
+        class BadVLA(struct):
+            n: c_int
+            data: array[c_int, "nonexistent_field"]
+
+        with self.assertRaises(ValueError):
+            BadVLA(MemoryResolver(bytearray(16), 0))
+
+    def test_undefined_count_field_descriptor_form(self):
+        from libdestruct.backing.memory_resolver import MemoryResolver
+        from libdestruct.common.array.vla_of import vla_of
+
+        class BadVLA(struct):
+            n: c_int
+            data: array = vla_of(c_int, "nonexistent_field")
+
+        with self.assertRaises(ValueError):
+            BadVLA(MemoryResolver(bytearray(16), 0))
+
+
 if __name__ == "__main__":
     unittest.main()

test/scripts/types_test.py

@@ -970,6 +970,22 @@ def test_unwrap_bytes_returns_live_data(self):
         self.assertEqual(p.unwrap(4), b"BBBB")
 
 
+class ObjHashableTest(unittest.TestCase):
+    """obj subclasses must be hashable (Python sets __hash__ = None when only __eq__ is defined)."""
+
+    def test_c_int_in_set(self):
+        x = c_int.from_bytes((1).to_bytes(4, "little"))
+        self.assertIn(x, {x})
+
+    def test_struct_in_dict(self):
+        class S(struct):
+            x: c_int
+
+        s = S.from_bytes((42).to_bytes(4, "little"))
+        d = {s: "value"}
+        self.assertEqual(d[s], "value")
+
+
 class PtrArithmeticSubclassTest(unittest.TestCase):
     """Pointer arithmetic must preserve subclass identity (e.g. for narrower pointer widths)."""