feat(arrays): array_slice() on an indexed string array

[Guikingone]

Part of #675 — the array_slice member. The issue's headline repro:

print_r(array_slice(["a", "b", "c"], 1, 2));

unsupported EIR backend feature: array_slice indexed-array element PHP type Str

An indexed array<string> stores 16-byte {pointer, length} slots, and both existing helpers copy 8 bytes per element — so a string receiver was refused at compile time rather than miscompiled. __rt_array_slice_str copies the pair.

Following array_splice_str

The issue names __rt_array_splice_str as the model, and this follows it in both respects.

The destination is allocated with 16-byte slots, and the copy duplicates through __rt_array_push_str (which persists via __rt_str_persist) rather than aliasing. A string array owns its bytes exclusively and array_slice() leaves its argument untouched, so both arrays end up owning independent copies and freeing either one is safe.

The window arithmetic is not re-derived: it goes through the shared emit_slice_bounds prologue every other array_slice variant uses, so negative offsets, negative lengths, clamping and an omitted $length behave identically by construction rather than by coincidence.

One detail worth flagging for review: the loop index is spilled rather than parked in a register. __rt_array_push_str persists the payload and may grow the destination, so it is a full call and every caller-saved register is fair game across it.

Measured

Eighteen rows byte-identical to the host PHP 8.5.10 — the whole offset/length matrix (mid, from, all, neg-off, neg-off-len, neg-len, neg-both, zero-len, past-end, too-long, too-far-back, empty-src, null-len), plus the four that are really about ownership:

write into the result	source unchanged
slice returned from a function	outlives the local it came from
slice of a slice	independent again
100/200/300-byte strings	real heap buffers, not anything inline

200 slices in a loop report allocs=1400 frees=1400 under --gc-stats — no leak, no double free. That is asserted as its own test, because getting the duplication wrong in either direction is silent at the value level: the strings still print.

Verified against the defect by putting the layout gate back: the fixture then fails with the exact message above.

Suites: codegen::arrays 568, codegen::strings 352, codegen::runtime_gc 298, error_tests 1534, --bin elephc 1915 — clean.

Still refused, deliberately not in this PR

array_chunk, array_pad, array_reverse, array_merge, array_unique, array_diff and shuffle still report their own variant of the message, so #675 stays open.

The first four are the same copy shape as this one and should follow quickly. array_unique and array_diff need string comparison over 16-byte slots, and shuffle needs in-place 16-byte swaps — different pieces of work with their own ownership questions. Landing them one at a time keeps each helper's contract reviewable on its own rather than burying eight assembly emitters in one diff.

🤖 Generated with Claude Code

https://claude.ai/code/session_01KSAAWPyNBq6dP2b5puN3wr

[greptile-apps]

Confidence Score: 5/5

The PR appears safe to merge; the implementation, ownership behavior, documentation, example, and supported-target coverage are aligned.

Summary

This PR enables array_slice() for indexed string arrays by selecting a dedicated runtime helper that allocates 16-byte string slots and persists each copied string so the result owns independent storage.

• Adds AArch64 and Linux x86_64 implementations of __rt_array_slice_str.
• Routes indexed string arrays to the new helper while retaining shared slice-bound normalization.
• Adds PHP behavior, ownership/GC, and supported-target emission regressions.
• Adds the required example and updates user-facing and internal runtime documentation.

Diagram

%%{init: {'theme': 'neutral'}}%%
flowchart LR
    A["array_slice(array<string>, offset, length)"] --> B["Shared slice-bound normalization"]
    B --> C["__rt_array_new with 16-byte slots"]
    C --> D["Read each {pointer, length} pair"]
    D --> E["__rt_array_push_str"]
    E --> F["Persist independent string bytes"]
    F --> G["Return independently owned slice"]

Loading

_{Reviews (5) · Last reviewed commit: "docs(arrays): the example, the runtime p..."}