fix: correct wrong enum_of implementation in code and docs

Author: MrIndeciso

SKILL.md

@@ -234,7 +234,7 @@ Legacy syntax with `enum_of()` is still supported:
 
 ```python
 class pixel_t(struct):
-    color: c_int = enum_of(Color)
+    color: enum = enum_of(Color)
     alpha: c_int
 ```
 

docs/advanced/forward_refs.md

@@ -21,11 +21,11 @@ At inflation time, the string `"Node"` is resolved to the actual `Node` class. T
 For the common case of a pointer to the enclosing struct, the legacy `ptr_to_self` syntax is also available:
 
 ```python
-from libdestruct import struct, c_int, ptr_to_self
+from libdestruct import struct, c_int, ptr, ptr_to_self
 
 class Node(struct):
     val: c_int
-    next: ptr_to_self
+    next: ptr = ptr_to_self()
 ```
 
 This is equivalent to `ptr["Node"]` but doesn't require you to spell out the type name. The `ptr["TypeName"]` syntax is preferred as it is more explicit.

docs/basics/enums.md

@@ -32,7 +32,7 @@ The legacy `enum_of()` syntax is also supported:
 from libdestruct import struct, c_int, enum_of
 
 class pixel_t(struct):
-    color: enum_of(Color, c_int)
+    color: enum = enum_of(Color)
     x: c_int
     y: c_int
 ```

libdestruct/common/struct/struct_impl.py

@@ -259,7 +259,13 @@ def hexdump(self: struct_impl) -> str:
         """Return a hex dump of this struct's bytes with field annotations."""
         member_offsets = object.__getattribute__(self, "_member_offsets")
         members = object.__getattribute__(self, "_members")
-        annotations = {member_offsets[name]: name for name in members}
+        annotations: dict[int, str] = {}
+        for name in members:
+            off = member_offsets[name]
+            if off in annotations:
+                annotations[off] += ", " + name
+            else:
+                annotations[off] = name
         address = struct_impl.address.fget(self) if not object.__getattribute__(self, "_frozen") else 0
         return format_hexdump(self.to_bytes(), address, annotations)
 

libdestruct/common/union/union.py

@@ -101,12 +101,11 @@ def diff(self: union) -> tuple[object, object]:
         return {name: v.diff() for name, v in self._variants.items()}
 
     def reset(self: union) -> None:
-        """Reset the union to its frozen value."""
-        if self._variant is not None:
-            self._variant.reset()
-        else:
-            for v in self._variants.values():
-                v.reset()
+        """Reset the union to its frozen value by restoring the full frozen byte region."""
+        if self._frozen_bytes is None:
+            raise RuntimeError("Cannot reset a union that has not been frozen.")
+        if self.resolver is not None:
+            self.resolver.modify(self.size, 0, self._frozen_bytes)
 
     def to_str(self: union, indent: int = 0) -> str:
         """Return a string representation of the union."""

libdestruct/common/utils.py

@@ -27,12 +27,21 @@ def is_field_bound_method(item: obj) -> bool:
 
 def size_of(item_or_inflater: obj | callable[[Resolver], obj]) -> int:
     """Return the size in bytes of a type, instance, or field descriptor."""
+    from types import GenericAlias
+
     # Field instances (e.g. array_of, ptr_to) — must come before .size check
     if isinstance(item_or_inflater, Field):
         return item_or_inflater.get_size()
     if is_field_bound_method(item_or_inflater):
         return item_or_inflater.__self__.get_size()
 
+    # Subscripted GenericAlias types (e.g. array[c_int, 10], enum[Color], ptr[T])
+    if isinstance(item_or_inflater, GenericAlias):
+        from libdestruct.common.type_registry import TypeRegistry
+
+        inflater = TypeRegistry().inflater_for(item_or_inflater)
+        return size_of(inflater)
+
     # Struct types: size is on the inflated _type_impl class
     if isinstance(item_or_inflater, type) and hasattr(item_or_inflater, "_type_impl"):
         return item_or_inflater._type_impl.size

test/scripts/struct_unit_test.py

@@ -524,5 +524,92 @@ class s_t(struct):
         self.assertEqual(size_of(s_t), 2)
 
 
+class SizeOfGenericAliasTest(unittest.TestCase):
+    """size_of() must handle subscripted GenericAlias types like array[c_int, 10]."""
+
+    def test_size_of_subscripted_array(self):
+        self.assertEqual(size_of(array[c_int, 10]), 40)
+
+    def test_size_of_subscripted_enum(self):
+        from enum import IntEnum
+
+        class Color(IntEnum):
+            RED = 0
+
+        self.assertEqual(size_of(enum[Color]), 4)
+        self.assertEqual(size_of(enum[Color, c_short]), 2)
+
+    def test_size_of_subscripted_ptr(self):
+        self.assertEqual(size_of(ptr[c_int]), 8)
+
+
+class UnionResetTest(unittest.TestCase):
+    """union.reset() must restore the full frozen byte region."""
+
+    def test_tagged_union_reset_struct_variant(self):
+        """reset() on a tagged union with a struct variant must not crash."""
+        import struct as pystruct
+
+        class point_t(struct):
+            x: c_int
+            y: c_int
+
+        class msg_t(struct):
+            tag: c_int
+            payload: union = tagged_union("tag", {0: c_int, 1: point_t})
+
+        memory = bytearray(12)
+        memory[0:4] = pystruct.pack("<i", 1)   # tag = 1 → point_t
+        memory[4:8] = pystruct.pack("<i", 10)  # x = 10
+        memory[8:12] = pystruct.pack("<i", 20) # y = 20
+
+        lib = inflater(memory)
+        msg = lib.inflate(msg_t, 0)
+        msg.freeze()
+
+        # Corrupt memory
+        memory[4:12] = b"\xff" * 8
+        msg.payload.reset()
+
+        # Verify restored
+        self.assertEqual(msg.payload.variant.x.value, 10)
+        self.assertEqual(msg.payload.variant.y.value, 20)
+
+    def test_plain_union_reset(self):
+        """reset() on a plain union must restore the full frozen region."""
+        import struct as pystruct
+
+        memory = bytearray(8)
+        memory[0:8] = pystruct.pack("<q", 0x1234567890ABCDEF)
+
+        class s_t(struct):
+            data: union = union_of({"i": c_int, "l": c_long})
+
+        lib = inflater(memory)
+        s = lib.inflate(s_t, 0)
+        s.freeze()
+
+        memory[0:8] = b"\x00" * 8
+        s.data.reset()
+
+        self.assertEqual(s.data.l.value, 0x1234567890ABCDEF)
+
+
+class HexdumpBitfieldAnnotationsTest(unittest.TestCase):
+    """hexdump() must show all bitfield names at the same offset."""
+
+    def test_bitfield_hexdump_shows_all_names(self):
+        class flags_t(struct):
+            read: c_int = bitfield_of(c_int, 1)
+            write: c_int = bitfield_of(c_int, 1)
+            execute: c_int = bitfield_of(c_int, 1)
+
+        f = flags_t.from_bytes(b"\x07\x00\x00\x00")
+        dump = f.hexdump()
+        self.assertIn("read", dump)
+        self.assertIn("write", dump)
+        self.assertIn("execute", dump)
+
+
 if __name__ == "__main__":
     unittest.main()

test/scripts/to_dict_test.py

@@ -56,8 +56,8 @@ class entity_t(struct):
         result = entity.to_dict()
         self.assertEqual(result, {"id": 1, "pos": {"x": 10, "y": 20}})
 
-    def test_struct_with_ptr_to_dict(self):
-        """Pointer field returns its address as int."""
+    def test_struct_with_long_to_dict(self):
+        """Integer field returns its value."""
         class data_t(struct):
             value: c_int
             ref: c_long