fix: solve various issues in the codebase that Opus created and then fixed itself

Author: MrIndeciso

libdestruct/c/c_float_types.py

@@ -41,6 +41,10 @@ def __float__(self: c_float) -> float:
         """Return the value as a Python float."""
         return self.get()
 
+    def __int__(self: c_float) -> int:
+        """Return the value as a Python int."""
+        return int(self.get())
+
 
 class c_double(obj):
     """A C double (IEEE 754 double-precision, 64-bit)."""
@@ -71,3 +75,7 @@ def to_bytes(self: c_double) -> bytes:
     def __float__(self: c_double) -> float:
         """Return the value as a Python float."""
         return self.get()
+
+    def __int__(self: c_double) -> int:
+        """Return the value as a Python int."""
+        return int(self.get())

libdestruct/c/struct_parser.py

@@ -57,6 +57,12 @@
 """A cache for parsed type definitions, indexed by name."""
 
 
+def clear_parser_cache() -> None:
+    """Clear cached struct definitions and typedefs from previous parses."""
+    PARSED_STRUCTS.clear()
+    TYPEDEFS.clear()
+
+
 def definition_to_type(definition: str) -> type[obj]:
     """Converts a C struct definition to a struct object."""
     parser = c_parser.CParser()

libdestruct/common/bitfield/bitfield.py

@@ -95,6 +95,12 @@ def to_bytes(self: bitfield) -> bytes:
             return self._backing_instance.to_bytes()
         return b""
 
+    def freeze(self: bitfield) -> None:
+        """Freeze the bitfield, also freezing the shared backing instance if this is the group owner."""
+        if self._is_group_owner and not self._backing_instance._frozen:
+            self._backing_instance.freeze()
+        super().freeze()
+
     def to_str(self: bitfield, _: int = 0) -> str:
         """Return a string representation of the bitfield."""
         return f"{self.get()}"

libdestruct/common/bitfield/bitfield_tracker.py

@@ -36,6 +36,13 @@ def active(self: BitfieldTracker) -> bool:
         """Return whether a bitfield group is currently active."""
         return self._backing_type is not None
 
+    def needs_new_group(self: BitfieldTracker, field: BitfieldField) -> bool:
+        """Return whether the given field would start a new bitfield group."""
+        return (
+            self._backing_type is not field.backing_type
+            or self._bit_offset + field.bit_width > field.backing_type.size * 8
+        )
+
     def flush(self: BitfieldTracker) -> int:
         """Close the current bitfield group and return the byte size to advance.
 

libdestruct/common/obj.py

@@ -135,7 +135,7 @@ def _compare_value(self: obj, other: object) -> tuple[object, object] | None:
         self_val = self.value
         if isinstance(other, obj):
             return self_val, other.value
-        if isinstance(other, int | float):
+        if isinstance(other, int | float | bytes):
             return self_val, other
         return None
 

libdestruct/common/struct/struct_impl.py

@@ -80,13 +80,14 @@ def _inflate_struct_attributes(
         current_offset = 0
         bf_tracker = BitfieldTracker()
         aligned = getattr(reference_type, "_aligned_", False)
+        self._member_offsets = {}
 
         for name, annotation, reference in iterate_annotation_chain(reference_type, terminate_at=struct):
             if name == "_aligned_":
                 continue
 
-            resolved_type, bitfield_field, explicit_offset = self._resolve_field(
-                name, annotation, reference, inflater, reference_type,
+            resolved_type, bitfield_field, explicit_offset = struct_impl._resolve_field(
+                name, annotation, reference, inflater, owner=(self, reference_type._type_impl),
             )
 
             if explicit_offset is not None:
@@ -95,6 +96,10 @@ def _inflate_struct_attributes(
                 current_offset = explicit_offset
 
             if bitfield_field:
+                if aligned and bf_tracker.needs_new_group(bitfield_field):
+                    current_offset += bf_tracker.flush()
+                    current_offset = _align_offset(current_offset, alignment_of(bitfield_field.backing_type))
+                self._member_offsets[name] = current_offset
                 result, offset_delta = bf_tracker.create_bitfield(
                     bitfield_field, inflater, resolver, current_offset,
                 )
@@ -103,20 +108,21 @@ def _inflate_struct_attributes(
                 current_offset += bf_tracker.flush()
                 if aligned and explicit_offset is None:
                     current_offset = _align_offset(current_offset, alignment_of(resolved_type))
+                self._member_offsets[name] = current_offset
                 result = resolved_type(resolver.relative_from_own(current_offset, 0))
                 current_offset += size_of(result)
 
             self._members[name] = result
 
         current_offset += bf_tracker.flush()
 
+    @staticmethod
     def _resolve_field(
-        self: struct_impl,
         name: str,
         annotation: type,
         reference: type,
         inflater: TypeRegistry,
-        reference_type: type,
+        owner: tuple[obj, type] | None,
     ) -> tuple[object | None, BitfieldField | None, int | None]:
         """Resolve a single struct field annotation to its inflater or BitfieldField.
 
@@ -126,7 +132,7 @@ def _resolve_field(
             explicit_offset is set when an OffsetAttribute is present.
         """
         if name not in reference.__dict__:
-            return inflater.inflater_for(annotation, owner=(self, reference_type._type_impl)), None, None
+            return inflater.inflater_for(annotation, owner=owner), None, None
 
         attrs = getattr(reference, name)
         if not isinstance(attrs, tuple):
@@ -144,15 +150,15 @@ def _resolve_field(
                 bitfield_field = attr
             elif isinstance(attr, Field):
                 resolved_type = inflater.inflater_for(
-                    (attr, annotation), owner=(self, reference_type._type_impl),
+                    (attr, annotation), owner=owner,
                 )
             elif isinstance(attr, OffsetAttribute):
                 explicit_offset = attr.offset
             else:
                 raise TypeError("Only Field, BitfieldField, and OffsetAttribute are allowed in attributes.")
 
         if not resolved_type and not bitfield_field:
-            resolved_type = inflater.inflater_for(annotation, owner=(self, reference_type._type_impl))
+            resolved_type = inflater.inflater_for(annotation, owner=owner)
 
         return resolved_type, bitfield_field, explicit_offset
 
@@ -168,46 +174,39 @@ def compute_own_size(cls: type[struct_impl], reference_type: type) -> None:
             if name == "_aligned_":
                 continue
 
-            bitfield_field = None
-            attribute = None
-            has_explicit_offset = False
-
-            if name in reference.__dict__:
-                attrs = getattr(reference, name)
-                if not isinstance(attrs, tuple):
-                    attrs = (attrs,)
-
-                if sum(isinstance(attr, Field) for attr in attrs) > 1:
-                    raise ValueError("Only one Field is allowed per attribute.")
-
-                for attr in attrs:
-                    if isinstance(attr, BitfieldField):
-                        bitfield_field = attr
-                    elif isinstance(attr, Field):
-                        attribute = cls._inflater.inflater_for((attr, annotation), (None, cls))(None)
-                    elif isinstance(attr, OffsetAttribute):
-                        has_explicit_offset = True
-                        offset = attr.offset
-                        if offset < size:
-                            raise ValueError("Offset must be greater than the current size.")
-                        size = offset
-
-                if not attribute and not bitfield_field:
-                    attribute = cls._inflater.inflater_for(annotation, (None, cls))
-            elif isinstance(annotation, Field):
-                attribute = cls._inflater.inflater_for((annotation, annotation.base_type), (None, cls))(None)
-            else:
-                attribute = cls._inflater.inflater_for(annotation, (None, cls))
+            resolved_type, bitfield_field, explicit_offset = struct_impl._resolve_field(
+                name, annotation, reference, cls._inflater, owner=(None, cls),
+            )
+
+            has_explicit_offset = explicit_offset is not None
+            if has_explicit_offset:
+                if explicit_offset < size:
+                    raise ValueError("Offset must be greater than the current size.")
+                size = explicit_offset
 
             if bitfield_field:
+                if aligned and bf_tracker.needs_new_group(bitfield_field):
+                    size += bf_tracker.flush()
+                    field_align = alignment_of(bitfield_field.backing_type)
+                    max_alignment = max(max_alignment, field_align)
+                    size = _align_offset(size, field_align)
                 size += bf_tracker.compute_size(bitfield_field)
             else:
                 size += bf_tracker.flush()
+                # Get attribute for size computation — try size_of directly first,
+                # falling back to calling the inflater with None for complex fields.
+                # Direct size_of avoids recursion for forward-ref pointers.
+                try:
+                    attribute_size = size_of(resolved_type)
+                    attribute = resolved_type
+                except (ValueError, TypeError):
+                    attribute = resolved_type(None)
+                    attribute_size = size_of(attribute)
                 if aligned and not has_explicit_offset:
                     field_align = alignment_of(attribute)
                     max_alignment = max(max_alignment, field_align)
                     size = _align_offset(size, field_align)
-                size += size_of(attribute)
+                size += attribute_size
 
         size += bf_tracker.flush()
 
@@ -232,21 +231,19 @@ def get(self: struct_impl) -> str:
         return f"{name}(address={addr}, size={size_of(self)})"
 
     def to_bytes(self: struct_impl) -> bytes:
-        """Return the serialized representation of the struct."""
-        return b"".join(member.to_bytes() for member in self._members.values())
+        """Return the serialized representation of the struct, including padding."""
+        if self._frozen:
+            return self._frozen_struct_bytes
+        return self.resolver.resolve(size_of(self), 0)
 
     def to_dict(self: struct_impl) -> dict[str, object]:
         """Return a JSON-serializable dict of field names to values."""
         return {name: member.to_dict() for name, member in self._members.items()}
 
     def hexdump(self: struct_impl) -> str:
         """Return a hex dump of this struct's bytes with field annotations."""
-        annotations = {}
-        offset = 0
-        for name, member in self._members.items():
-            annotations[offset] = name
-            offset += len(member.to_bytes())
-
+        member_offsets = object.__getattribute__(self, "_member_offsets")
+        annotations = {member_offsets[name]: name for name in self._members}
         address = struct_impl.address.fget(self) if not self._frozen else 0
         return format_hexdump(self.to_bytes(), address, annotations)
 
@@ -255,8 +252,9 @@ def _set(self: struct_impl, _: str) -> None:
         raise RuntimeError("Cannot set the value of a struct.")
 
     def freeze(self: struct_impl) -> None:
-        """Freeze the struct."""
-        # The struct has no implicit value, but it must freeze its members
+        """Freeze the struct, capturing the full byte representation including padding."""
+        self._frozen_struct_bytes = self.resolver.resolve(size_of(self), 0)
+
         for member in self._members.values():
             member.freeze()
 
@@ -288,7 +286,7 @@ def __repr__(self: struct_impl) -> str:
     def __eq__(self: struct_impl, value: object) -> bool:
         """Return whether the struct is equal to the given value."""
         if not isinstance(value, struct_impl):
-            return False
+            return NotImplemented
 
         if size_of(self) != size_of(value):
             return False

libdestruct/common/union/union.py

@@ -94,6 +94,20 @@ def freeze(self: union) -> None:
             v.freeze()
         super().freeze()
 
+    def diff(self: union) -> tuple[object, object]:
+        """Return the difference between the frozen and current value."""
+        if self._variant is not None:
+            return self._variant.diff()
+        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()
+
     def to_str(self: union, indent: int = 0) -> str:
         """Return a string representation of the union."""
         if self._variant is not None:

test/scripts/alignment_test.py

@@ -212,3 +212,59 @@ class s_t(struct):
             c: c_int  # should be at offset 8 (aligned to 4)
 
         self.assertEqual(size_of(s_t), 12)  # 4 + 1 + 3 padding + 4
+
+
+class AlignedStructSerializationTest(unittest.TestCase):
+    def test_aligned_struct_to_bytes_includes_padding(self):
+        """to_bytes on aligned struct includes padding bytes."""
+        class aligned_t(struct):
+            _aligned_ = True
+            a: c_char
+            b: c_int
+
+        memory = pystruct.pack("<b", 0x41) + b"\x00" * 3 + pystruct.pack("<i", 42)
+        s = aligned_t.from_bytes(memory)
+        # to_bytes should be 8 bytes (including padding), not 5
+        self.assertEqual(len(s.to_bytes()), 8)
+
+    def test_aligned_struct_to_bytes_round_trip(self):
+        """from_bytes(to_bytes()) preserves values for aligned structs."""
+        class aligned_t(struct):
+            _aligned_ = True
+            a: c_char
+            b: c_int
+
+        memory = pystruct.pack("<b", 0x41) + b"\x00" * 3 + pystruct.pack("<i", 42)
+        s1 = aligned_t.from_bytes(memory)
+        s2 = aligned_t.from_bytes(s1.to_bytes())
+        self.assertEqual(s2.a.value, 0x41)
+        self.assertEqual(s2.b.value, 42)
+
+
+class BitfieldAlignmentTest(unittest.TestCase):
+    def test_bitfield_alignment_padding(self):
+        """Bitfield backing type is aligned in aligned structs."""
+        from libdestruct import bitfield_of
+
+        class s_t(struct):
+            _aligned_ = True
+            a: c_char
+            flags: c_int = bitfield_of(c_int, 3)
+
+        # c_char (1) + 3 padding + c_int backing (4) = 8
+        self.assertEqual(size_of(s_t), 8)
+
+    def test_bitfield_alignment_read(self):
+        """Bitfield values read correctly in aligned structs."""
+        from libdestruct import bitfield_of
+        from libdestruct import c_uint
+
+        class s_t(struct):
+            _aligned_ = True
+            a: c_char
+            flags: c_uint = bitfield_of(c_uint, 3)
+
+        memory = pystruct.pack("<b", 0x41) + b"\x00" * 3 + pystruct.pack("<I", 5)
+        s = s_t.from_bytes(memory)
+        self.assertEqual(s.a.value, 0x41)
+        self.assertEqual(s.flags.value, 5)

test/scripts/bitfield_unit_test.py

@@ -6,7 +6,7 @@
 
 import unittest
 
-from libdestruct import c_int, c_uint, c_long, struct, bitfield_of
+from libdestruct import c_int, c_uint, c_long, inflater, struct, bitfield_of
 from libdestruct.c.struct_parser import definition_to_type
 
 
@@ -139,5 +139,23 @@ def test_bitfield_c_parser(self):
         self.assertEqual(test.reserved.value, 10)
 
 
+class BitfieldFreezeTest(unittest.TestCase):
+    def test_bitfield_freeze_to_bytes(self):
+        """Frozen bitfield struct to_bytes returns original bytes."""
+        memory = bytearray(4)
+        memory[0] = 0b_00101_011  # a=3, b=5
+
+        class flags_t(struct):
+            a: c_int = bitfield_of(c_int, 3)
+            b: c_int = bitfield_of(c_int, 5)
+
+        lib = inflater(memory)
+        s = lib.inflate(flags_t, 0)
+        original_bytes = bytes(s.to_bytes())
+        s.freeze()
+        memory[0] = 0xFF
+        self.assertEqual(s.to_bytes(), original_bytes)
+
+
 if __name__ == "__main__":
     unittest.main()

test/scripts/struct_unit_test.py

@@ -236,5 +236,15 @@ class TreeNode(struct):
         self.assertEqual(node.data.value, 42)
 
 
+class StructEqualityTest(unittest.TestCase):
+    def test_struct_eq_non_struct_returns_not_implemented(self):
+        """struct.__eq__ returns NotImplemented for non-struct values."""
+        class s_t(struct):
+            x: c_int
+
+        s = s_t.from_bytes(b"\x01\x00\x00\x00")
+        self.assertIs(s.__eq__(42), NotImplemented)
+
+
 if __name__ == "__main__":
     unittest.main()