fix: evaluate list literals / deep call chains left-to-right

[pyrex41]

The divergence

shen-lua evaluated the elements of a list literal right to left once the
literal reached 16 elements. shen-go, shen-cl and shen-rust all evaluate
left to right, so any side-effecting expression inside a list literal was
port-dependent. It broke a urdr test suite whose own output became
port-dependent (urdr d426237).

Same source, all four ports ((define demo X -> [(output "~A " 0) ... (output "~A " 19)])):

port	output
shen-go	0 1 2 3 ... 19
shen-cl	0 1 2 3 ... 19
shen-rust	0 1 2 3 ... 19
shen-lua (before)	19 18 17 ... 0
shen-lua (after)	0 1 2 3 ... 19

Cause

compiler.lua's try_flatten_call_chain lowers a >=16-deep right-spine call
chain into a sequence of local bindings so the chain does not hit Lua's
~200-level expression-nesting parser limit. It built the chain inside out
and compiled each frame's non-last arguments at the call site it emitted for
that frame — so those arguments ran in reverse source order. A list literal's
KL form is exactly such a chain of cons calls, which is why the divergence
showed up there, and why the threshold was exactly 16.

Nothing else reorders: the MKLIST path (value position, >=16 elements) and
the MKTREE path (>=60 cons nodes) both already emit left to right, and
try_let_float already guards on arg_pure. Below 16 frames the lowering
does not fire at all, which is why short lists always looked correct.

Fix

Non-last arguments are evaluated up front, outermost frame first, before the
innermost value; the call sites then only reference the results.

Two properties preserved deliberately:

• Only observable arguments are hoisted. arg_pure operands (atoms,
  unbound symbols, bound Lua locals) have no effects and cannot be disturbed
  by a later one, so they stay inline. The Prolog compiler's
  shen.gc(A, shen.gc(A, ...)) CPS spines — the chains this lowering exists
  for — are entirely of that kind, and their generated Lua is byte-for-byte
  unchanged (verified by diffing codegen before/after).
• Hoisted values go into one scratch table, not into locals. Lua allows
  200 locals per function and the chain already spends one per frame, so
  hoisting into locals would halve the depth this lowering can handle. The
  table is emitted only when something actually needs hoisting.

Tests

New test/eval_order_spec.lua (40 checks), registered in scripts/run-tests.lua.
It pins left-to-right order for list literals in tail / argument / value
position at 3, 15, 16, 20 and 70 elements; deep user call chains with effectful
non-last arguments; and the collateral constructs that must not have
changed — application arguments, nested applications, let, do, arithmetic,
@p, @v, @s, if branch selection, freeze/thaw deferral. It also
pins that the flattening optimisation still fires (a 150-deep spine still
compiles to loadable Lua, and the pure chain still allocates no scratch table),
so a future "fix" that just disabled the lowering would fail here.

The first commit adds the spec failing; the second makes it pass.

TOTAL: 540 pass, 0 fail across 15 specs     (main: 500 pass, 0 fail across 14)
ALL PORT SPECS GREEN

make certify: passed ... 134 / failed ... 0 / pass rate ... 100%   (unchanged from main)

All twelve collateral constructs were also run through all four ports directly
and produce identical traces.

🤖 Generated with Claude Code