fix: struct freezing didn't work correctly, alignment was broken for arrays

Author: MrIndeciso

libdestruct/common/struct/struct.py

@@ -34,4 +34,6 @@ def from_bytes(cls: type[struct], data: bytes, endianness: str = "little") -> st
         """Create a struct from a serialized representation."""
         type_inflater = inflater(data, endianness=endianness)
 
-        return type_inflater.inflate(cls, 0)
+        result = type_inflater.inflate(cls, 0)
+        result.freeze()
+        return result

libdestruct/common/struct/struct_impl.py

@@ -234,7 +234,8 @@ def to_bytes(self: struct_impl) -> bytes:
         """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)
+        resolver = object.__getattribute__(self, "resolver")
+        return 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."""
@@ -253,12 +254,13 @@ def _set(self: struct_impl, _: str) -> None:
 
     def freeze(self: struct_impl) -> None:
         """Freeze the struct, capturing the full byte representation including padding."""
-        self._frozen_struct_bytes = self.resolver.resolve(size_of(self), 0)
+        resolver = object.__getattribute__(self, "resolver")
+        self._frozen_struct_bytes = resolver.resolve(size_of(self), 0)
 
         for member in self._members.values():
             member.freeze()
 
-        self._frozen = True
+        super().freeze()
 
     def to_str(self: struct_impl, indent: int = 0) -> str:
         """Return a string representation of the struct."""

libdestruct/common/utils.py

@@ -81,11 +81,16 @@ 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
+    # Field descriptors — for array fields, alignment comes from the element type
     if isinstance(item, Field):
+        if hasattr(item, "item"):
+            return alignment_of(item.item)
         return _alignment_from_size(item.get_size())
     if is_field_bound_method(item):
-        return _alignment_from_size(item.__self__.get_size())
+        field = item.__self__
+        if hasattr(field, "item"):
+            return alignment_of(field.item)
+        return _alignment_from_size(field.get_size())
 
     # Derive from size for power-of-2 sized types
     try:

test/scripts/alignment_test.py

@@ -241,6 +241,46 @@ class aligned_t(struct):
         self.assertEqual(s2.b.value, 42)
 
 
+class ArrayAlignmentTest(unittest.TestCase):
+    def test_alignment_of_array_field(self):
+        """alignment_of(array_of(c_int, N)) should be 4 (element alignment), not 1."""
+        from libdestruct import array_of
+
+        arr = array_of(c_int, 3)
+        self.assertEqual(alignment_of(arr), 4)
+
+    def test_aligned_struct_with_array(self):
+        """Array field in aligned struct should be aligned to element alignment."""
+        from libdestruct import array_of
+
+        class s_t(struct):
+            _aligned_ = True
+            a: c_char
+            arr: list[c_int] = array_of(c_int, 3)
+
+        # a at 0 (1 byte), padding 3, arr at 4 (12 bytes) = 16, tail padded to 4 = 16
+        self.assertEqual(size_of(s_t), 16)
+
+    def test_aligned_struct_with_array_read(self):
+        """Values read correctly from aligned array in struct."""
+        from libdestruct import array_of
+
+        class s_t(struct):
+            _aligned_ = True
+            a: c_char
+            arr: list[c_int] = array_of(c_int, 3)
+
+        memory = pystruct.pack("<b", 0x41) + b"\x00" * 3
+        for v in [10, 20, 30]:
+            memory += pystruct.pack("<i", v)
+
+        s = s_t.from_bytes(memory)
+        self.assertEqual(s.a.value, 0x41)
+        self.assertEqual(s.arr[0].value, 10)
+        self.assertEqual(s.arr[1].value, 20)
+        self.assertEqual(s.arr[2].value, 30)
+
+
 class BitfieldAlignmentTest(unittest.TestCase):
     def test_bitfield_alignment_padding(self):
         """Bitfield backing type is aligned in aligned structs."""

test/scripts/struct_unit_test.py

@@ -198,6 +198,34 @@ class test_t(struct):
         with self.assertRaises(ValueError):
             test.a.value = 999
 
+    def test_frozen_struct_value_not_none(self):
+        """Frozen struct .value should not be None."""
+        class test_t(struct):
+            a: c_int
+
+        memory = bytearray(b"\x2a\x00\x00\x00")
+        lib = inflater(memory)
+        test = lib.inflate(test_t, 0)
+        test.freeze()
+        self.assertIsNotNone(test.value)
+
+    def test_from_bytes_struct_is_frozen(self):
+        """struct.from_bytes should return a frozen struct, like obj.from_bytes."""
+        class test_t(struct):
+            a: c_int
+
+        test = test_t.from_bytes(b"\x2a\x00\x00\x00")
+        self.assertTrue(test._frozen)
+
+    def test_from_bytes_struct_rejects_writes(self):
+        """struct.from_bytes result should reject writes with ValueError, not TypeError."""
+        class test_t(struct):
+            a: c_int
+
+        test = test_t.from_bytes(b"\x2a\x00\x00\x00")
+        with self.assertRaises(ValueError):
+            test.a.value = 99
+
 
 class ForwardRefPtrTest(unittest.TestCase):
     """Forward reference ptr["Type"] syntax."""