sx/issues/0125-any-to-string-array-arms-by-value.md

0125 — any_to_string's array arms materialize every interned array type by value

RESOLVED (2026-06-19). Root cause as described below: the type-match dispatcher (lowerRuntimeDispatchCall, src/ir/lower/call.zig) unboxed each interned array tag to the concrete array type — a whole-array load — and fed it to array_to_string by value, which LLVM scalarized to one DAG node per element. Fix (route 1): any_to_string's case array: arm now calls slice_to_string (library/modules/std/fmt.sx); the dispatcher detects an ARRAY tag bound to a SLICE param and builds a {ptr,len} slice VIEW of the payload pointer (unbox_any → [*]elem is an int-to-ptr with NO load, paired with the array length) instead of loading the array. Output is byte-identical ([a, b, c]). The repro compiles fast and prints correctly; pinned as examples/0056-basic-large-array-format-no-blowup.sx.

Symptom

A program that (a) interns any large (~64KB+) array type and (b) uses {} formatting anywhere — print("{}\n", 5) of a plain int is enough — crashes sx build inside libLLVM (DAGCombiner::visitMERGE_VALUES → SelectionDAG::ReplaceAllUsesWith), and makes sx run (-O0) take ~18s to compile a trivial file. The two triggers are independent: the array need never be printed, sliced, or passed anywhere near the format call.

• Observed: segfault under sx build; multi-second compiles under sx run.
• Expected: formatting an int is unaffected by an unrelated large array type; printing the array itself formats in place.

Root cause shape: any_to_string's comptime type-switch (library/modules/std/fmt.sx, case array: arm) expands one arm per interned array type, and each arm is array_to_string(cast(type) val):

1. the cast(type) val unbox loads the WHOLE array from the Any payload pointer (coerceFromI64, src/ir/emit_llvm.zig ~2240, ua.load),
2. the call passes the array BY VALUE to the array_to_string mono,
3. the mono spills its by-value param to an alloca and (since the param is an SSA value, not addressable storage) reads elements via index_get on the value — copy-whole-array per element.

LLVM's legalizer scalarizes each whole-aggregate op into one SelectionDAG node per element; at ~64K elements the DAG combiner recurses to death (the sibling of issue 0124, which fixed the local-variable shapes: --- undef store and index reads on addressable storage).

Reproduction

#import "modules/std.sx";

f :: () {
    buf : [65536]u8 = ---;
    buf[0] = 1;
    out(string.{ ptr = @buf[0], len = 1 });
}

main :: () -> i32 {
    f();
    print("{}\n", 5);
    return 0;
}

Observed (with 0124's fix in place): sx build segfaults in libLLVM; sx ir shows the giant arm inside @any_to_string:

%ua.load = load [65536 x i8], ptr %ua.ptr, align 1
%call = call { ptr, i64 } @array_to_string__AR_65536_u8(ptr %0, [65536 x i8] %ua.load)

Investigation prompt

The fix needs the array formatting chain to never materialize the array as a first-class value. The Any payload for an array IS a pointer to its storage (that is what coerceFromI64 intToPtr+loads), so the arm has everything it needs to format in place. Plausible routes, most contained first:

1. Lower the case array: arm to a slice view: box the payload pointer + the array's element count as a []elem and call slice_to_string (slices unbox as a 16-byte {ptr,len} — no giant ops). Needs the element type at arm-expansion time — the comptime type-switch already has the concrete array TypeId in hand; an element_type(T)-style comptime accessor may need to be added for the sx-level spelling, or the arm can be synthesized in the compiler where both pieces are known.
2. Teach array_to_string :: (a: $T) monos (and the unbox cast) an indirect ABI for array-typed params — bigger blast radius: touches call emission, param spills, and many .ir snapshots.

Suspected files: src/ir/lower/comptime.zig / lower/call.zig (the type-switch arm expansion and cast(type) lowering), src/ir/emit_llvm.zig coerceFromI64, library/modules/std/fmt.sx (any_to_string, array_to_string).

Verification: the repro builds and runs printing 5; printing the array itself (print("{}\n", buf) on a small array) still renders element lists (pinned by 0101/0904 et al.); zig build test and bash tests/run_examples.sh green; the repro pinned as an example.