Serialize bytearray exports with resizing - #9087

Allow no-op initialization of exported empty bytearrays

When an empty bytearray already has a live memoryview, __init__() and __init__(0) perform no resize; CPython permits both and still invokes conversion callbacks for an int-like zero. The unconditional resize guard here instead raises BufferError before options conversion, regressing the previously successful no-op and suppressing those callbacks. Skip the initial guard/clear when the current length is zero and only reject if the eventual result actually needs a resize.

AGENTS.md reference: AGENTS.md:L7-L7

Useful? React with 👍 / 👎.

Release the previous allocation for zero-count initialization

When a large existing bytearray is reinitialized with an integer (or int-like value) of zero, this early return follows Vec::clear(), which preserves capacity, so bytearray.__alloc__() continues to expose the old allocation and potentially gigabytes remain held for the object's lifetime. The old implementation swapped in the newly created empty inner and released that storage; replace the backing vector while performing the initial clear so the zero-count callback behavior is kept without retaining the old allocation.

Useful? React with 👍 / 👎.

Validate the sequence index before rejecting an export

When a C extension calls PySequence_DelItem on a bytearray with a live export and a positive index at or beyond the current length, this guard runs before delitem_by_index can validate the bounds, so the call now raises BufferError; CPython's bytearray sequence slot reports IndexError for such an index without attempting a resize. Validate the index before acquiring the resize guard, then revalidate under the guard, so only a valid deletion is treated as a resize.

AGENTS.md reference: AGENTS.md:L7-L7

Useful? React with 👍 / 👎.

Reject reentrant initialization without self-deadlocking

When target + other reaches a Python other.__buffer__ that calls target.__init__(object()) (and catches the exception), AsSequence::concat is still holding target.inner() for reading. This new eager try_resizable then waits for the same thread's write lock, so the expression hangs; in the parent, invalid-source conversion raised TypeError before any write lock was taken and concatenation completed. Mark the outer borrow as an export so reentry gets BufferError, or otherwise avoid taking this write lock reentrantly.

Useful? React with 👍 / 👎.

Remove the prohibited test-logic additions

Remove this new regression snippet and the two sibling builtin_bytearray_* snippets: the repository's critical test policy allows test-file edits only for adding or removing expected-failure markers, whereas these files introduce new assertions, control flow, and test data. Keeping them in this change violates the contribution rules even if the tests pass.

AGENTS.md reference: AGENTS.md:L273-L279

Useful? React with 👍 / 👎.

Reject initializer reentry instead of waiting on the read lock

The new concat buffering removes the earlier target + other deadlock, but target == other still calls zelf.inner().cmp(...) with a read guard while other.__buffer__ runs. If that callback calls target.__init__(object()) and catches the exception, this eager try_resizable waits forever for the same thread's read guard; the parent converted the invalid source first and returned TypeError instead. Mark outer callback borrows such as comparison and starts/endswith as exports, or make this guard fail rather than wait reentrantly.

Useful? React with 👍 / 👎.

Remove the newly added concat test snippet

This fourth regression file is fresh evidence beyond the three snippets named in the existing review: it adds a loop, helper classes, and assertions even though the scoped critical policy permits test-file edits only to add or remove expected-failure decorators. Remove this test logic rather than expanding the prohibited test changes.

AGENTS.md reference: AGENTS.md:L273-L279

Useful? React with 👍 / 👎.

Avoid cloning both buffers during comparisons

When equal-length operands are large, and for every ordering comparison, these snapshots allocate and copy both complete operands before comparing them; even a == a for an exact bytearray now requires two full-size temporary allocations. The parent implementation compared borrowed slices without this extra 2× memory requirement, so otherwise valid comparisons can now raise MemoryError or cause severe allocation latency; keep the exports alive but compare lock-safe borrowed views, or retain the identity fast path for exact bytearrays.

AGENTS.md reference: AGENTS.md:L7-L7

Useful? React with 👍 / 👎.

do not make multiple tset files. move 5 files into builtin_bytearray.py

Remove the appended test logic

Fresh evidence beyond the earlier separate-snippet comments is that this squashed commit now appends the four regression bodies to builtin_bytearray.py, adding 591 lines of assertions, control flow, and test data. Consolidating them into an existing snippet does not resolve the critical policy violation, because test-file edits are limited to adding or removing expected-failure markers; remove this new test logic or obtain an explicit policy exception.

AGENTS.md reference: AGENTS.md:L273-L279

Useful? React with 👍 / 👎.

Snapshot aliased concat operands atomically

When both operands expose the same mutable bytearray (for example a + a) and another thread performs a same-length assignment, these two append_to calls acquire and release the bytearray read lock independently. Exports block resizing but not same-size writes, so the writer can run between the calls and produce an old left half plus a new right half, a result that no atomic execution of a + a can produce; reuse one snapshot when the root exporters alias, or otherwise keep the shared storage stable across both copies.

Useful? React with 👍 / 👎.

Treat source-less initialization as complete after clearing

When bytearray.__init__() is called without a source and another thread acquires a memoryview after the initial clear, get_inner_with_zero_count leaves this flag false, so the second resize guard raises BufferError. The call has already discarded the old contents and has no remaining write to perform, making a completed clear appear to fail; mark the missing-source case as no-further-write or keep the initial guard through that callback-free path.

Useful? React with 👍 / 👎.