fix: solve incorrect union alignment and enum backing type assumptions

Author: MrIndeciso

libdestruct/common/enum/enum_field_inflater.py

@@ -42,7 +42,7 @@ def _subscripted_enum_handler(
         return None
     python_enum = args[0]
     backing_type = args[1] if len(args) > 1 else c_int
-    field = IntEnumField(python_enum, size=backing_type.size)
+    field = IntEnumField(python_enum, backing_type=backing_type)
     return field.inflate
 
 

libdestruct/common/enum/int_enum_field.py

@@ -21,17 +21,28 @@
 class IntEnumField(EnumField):
     """A generator for an enum of integers."""
 
-    def __init__(self: IntEnumField, enum: type[IntEnum], lenient: bool = True, size: int = 4) -> None:
+    def __init__(
+        self: IntEnumField,
+        enum: type[IntEnum],
+        lenient: bool = True,
+        size: int = 4,
+        backing_type: type | None = None,
+    ) -> None:
         """Initialize the field.
 
         Args:
             enum: The enum class.
             lenient: Whether the conversion is lenient or not.
-            size: The size of the field in bytes.
+            size: The size of the field in bytes (used when backing_type is not provided).
+            backing_type: The explicit backing type to use. If provided, overrides size.
         """
         self.enum = enum
         self.lenient = lenient
 
+        if backing_type is not None:
+            self.backing_type = backing_type
+            return
+
         if not 0 < size <= 8:
             raise ValueError("The size of the field must be between 1 and 8 bytes.")
 

libdestruct/common/struct/struct_impl.py

@@ -93,6 +93,7 @@ def _inflate_struct_attributes(
             )
 
             if explicit_offset is not None:
+                current_offset += bf_tracker.flush()
                 if explicit_offset < current_offset:
                     raise ValueError("Offset must be greater than the current size.")
                 current_offset = explicit_offset
@@ -191,6 +192,7 @@ def compute_own_size(cls: type[struct_impl], reference_type: type) -> None:
 
             has_explicit_offset = explicit_offset is not None
             if has_explicit_offset:
+                size += bf_tracker.flush()
                 if explicit_offset < size:
                     raise ValueError("Offset must be greater than the current size.")
                 size = explicit_offset

libdestruct/common/union/tagged_union_field.py

@@ -10,7 +10,7 @@
 
 from libdestruct.common.field import Field
 from libdestruct.common.union.union import union
-from libdestruct.common.utils import size_of
+from libdestruct.common.utils import alignment_of, size_of
 
 if TYPE_CHECKING:  # pragma: no cover
     from libdestruct.backing.resolver import Resolver
@@ -43,3 +43,7 @@ def inflate(self: TaggedUnionField, resolver: Resolver | None) -> union:
     def get_size(self: TaggedUnionField) -> int:
         """Return the size of the union (max of all variant sizes)."""
         return max(size_of(variant) for variant in self.variants.values())
+
+    def get_alignment(self: TaggedUnionField) -> int:
+        """Return the alignment of the union (max of all variant alignments)."""
+        return max(alignment_of(variant) for variant in self.variants.values())

libdestruct/common/union/union_field.py

@@ -10,7 +10,7 @@
 
 from libdestruct.common.field import Field
 from libdestruct.common.union.union import union
-from libdestruct.common.utils import size_of
+from libdestruct.common.utils import alignment_of, size_of
 
 if TYPE_CHECKING:  # pragma: no cover
     from libdestruct.backing.resolver import Resolver
@@ -41,3 +41,7 @@ def inflate(self: UnionField, resolver: Resolver | None) -> union:
     def get_size(self: UnionField) -> int:
         """Return the size of the union (max of all variant sizes)."""
         return max(size_of(variant) for variant in self.variants.values())
+
+    def get_alignment(self: UnionField) -> int:
+        """Return the alignment of the union (max of all variant alignments)."""
+        return max(alignment_of(variant) for variant in self.variants.values())

libdestruct/common/utils.py

@@ -81,13 +81,17 @@ def alignment_of(item: obj | type[obj]) -> int:
     if isinstance(item, type) and "alignment" in item.__dict__ and isinstance(item.__dict__["alignment"], int):
         return item.__dict__["alignment"]
 
-    # Field descriptors — for array fields, alignment comes from the element type
+    # Field descriptors — use get_alignment if available, else derive from element type or size
     if isinstance(item, Field):
+        if hasattr(item, "get_alignment"):
+            return item.get_alignment()
         if hasattr(item, "item"):
             return alignment_of(item.item)
         return _alignment_from_size(item.get_size())
     if is_field_bound_method(item):
         field = item.__self__
+        if hasattr(field, "get_alignment"):
+            return field.get_alignment()
         if hasattr(field, "item"):
             return alignment_of(field.item)
         return _alignment_from_size(field.get_size())

test/scripts/struct_unit_test.py

@@ -9,7 +9,8 @@
 
 from typing import Annotated
 
-from libdestruct import array, c_int, c_long, c_short, c_uint, inflater, offset, struct, ptr, ptr_to_self, array_of, enum, enum_of
+from libdestruct import array, c_int, c_long, c_short, c_uint, c_ushort, inflater, offset, struct, ptr, ptr_to_self, array_of, enum, enum_of, size_of, bitfield_of
+from libdestruct.common.union import union, union_of, tagged_union
 
 
 class StructMemberCollisionTest(unittest.TestCase):
@@ -419,5 +420,109 @@ class s_t(struct):
         self.assertIs(s.__eq__(42), NotImplemented)
 
 
+class BitfieldExplicitOffsetTest(unittest.TestCase):
+    """Explicit offset after bitfields must flush the pending bitfield group first."""
+
+    def test_offset_after_bitfield_size(self):
+        """Struct size must be correct when offset() follows bitfield fields."""
+        class s_t(struct):
+            a: c_uint = bitfield_of(c_uint, 1)
+            b: c_int = offset(8)
+
+        # a is a 1-bit bitfield in a 4-byte c_uint group at offset 0.
+        # b is at explicit offset 8 with size 4.
+        # Total size: 8 + 4 = 12
+        self.assertEqual(size_of(s_t), 12)
+
+    def test_offset_after_bitfield_read(self):
+        """Values must be read correctly when offset() follows bitfield fields."""
+        import struct as pystruct
+
+        class s_t(struct):
+            a: c_uint = bitfield_of(c_uint, 1)
+            b: c_int = offset(8)
+
+        memory = bytearray(12)
+        memory[0:4] = pystruct.pack("<I", 1)   # a = 1
+        memory[8:12] = pystruct.pack("<i", 42)  # b = 42
+
+        s = s_t.from_bytes(memory)
+        self.assertEqual(s.a.value, 1)
+        self.assertEqual(s.b.value, 42)
+
+
+class UnionAlignmentTest(unittest.TestCase):
+    """Union fields in aligned structs must use member-derived alignment."""
+
+    def test_plain_union_alignment_non_power_of_two_size(self):
+        """Union of a 12-byte packed struct and c_long: size=12 but alignment must be 8 (from c_long)."""
+        class triple_t(struct):
+            a: c_int
+            b: c_int
+            c: c_int
+
+        # triple_t is a packed 12-byte struct with alignment 1
+        # c_long is 8 bytes with alignment 8
+        # union size = 12, but alignment should be 8 (max member alignment)
+        class s_t(struct):
+            _aligned_ = True
+            tag: c_short  # 2 bytes, align 2
+            data: union = union_of({"t": triple_t, "l": c_long})
+
+        # tag at offset 0 (2 bytes)
+        # data alignment = 8 → data at offset 8
+        # data size = 12
+        # struct max alignment = 8 → total = _align_offset(20, 8) = 24
+        self.assertEqual(size_of(s_t), 24)
+
+    def test_tagged_union_alignment_non_power_of_two_size(self):
+        """Tagged union of a 12-byte packed struct and c_long: alignment must be 8."""
+        class triple_t(struct):
+            a: c_int
+            b: c_int
+            c: c_int
+
+        class s_t(struct):
+            _aligned_ = True
+            tag: c_int  # 4 bytes, align 4
+            data: union = tagged_union("tag", {0: triple_t, 1: c_long})
+
+        # tag at offset 0 (4 bytes)
+        # data alignment = 8 → data at offset 8
+        # data size = 12
+        # struct max alignment = 8 → total = _align_offset(20, 8) = 24
+        self.assertEqual(size_of(s_t), 24)
+
+
+class SubscriptedEnumUnsignedTest(unittest.TestCase):
+    """enum[E, unsigned_backing] must preserve signedness."""
+
+    def test_enum_unsigned_backing(self):
+        """enum[E, c_ushort] should correctly decode values exceeding signed range."""
+        from enum import IntEnum
+
+        class E(IntEnum):
+            MAX_VAL = 0xFFFF
+
+        class s_t(struct):
+            val: enum[E, c_ushort]
+
+        memory = (0xFFFF).to_bytes(2, "little")
+        s = s_t.from_bytes(memory)
+        self.assertEqual(s.val.value, E.MAX_VAL)
+
+    def test_enum_unsigned_size(self):
+        """enum[E, c_ushort] struct should be 2 bytes."""
+        from enum import IntEnum
+
+        class E(IntEnum):
+            A = 0
+
+        class s_t(struct):
+            val: enum[E, c_ushort]
+
+        self.assertEqual(size_of(s_t), 2)
+
+
 if __name__ == "__main__":
     unittest.main()