Accept prefix-binop expressions as call arguments

[danieljohnmorris]

Summary

Resolves the most-cited ergonomic friction in the assessment doc: call args bailing too eagerly when a position started with a prefix-binary expression. The doc calls this "the single most repetitive ilo friction across both sessions; every program has 10+ intermediate names just for this."

Across 11 rounds of feedback and 4 personas, agents kept hitting:

slc ls i +i 1            → arity error, must bind ip=+i 1 first
prnt pct s 10            → same shape
i = flr */n 0.25         → same shape
slc xs fi +fi 1          → same shape (bioinformatics persona)

Every fix produces one or two saved intermediate bindings per call. Across a typical program that compounds into 10+ named temporaries the agent wouldn't otherwise need. Through the manifesto lens this is a recurring per-program token tax — exactly the kind of friction the language exists to remove.

Root cause

parse_call_or_atom's arg-collection loop (src/parser/mod.rs:1571-1585):

let mut args = Vec::new();
while self.can_start_operand() {
    args.push(self.parse_operand()?);
    if let Some(tok) = self.peek()
        && Self::infix_binding_power(tok).is_some()
    {
        break;          // ← too eager
    }
}

The break fires whenever the next token is infix-eligible, even when it actually starts a prefix-binary expression. The parser already has looks_like_prefix_binary and uses it at the top of the arg-collection block to disambiguate prefix vs infix when the first token after the function name is an operator. The inner break check didn't.

The fix

1. parser: accept prefix-binop expressions as call arguments — mirror the pre-loop guard inside the break. Only break when the operator looks infix (1 atom ahead), not when it looks prefix-binary (2+ atoms ahead). Also extended looks_like_prefix_binary to recognise nested prefix-binops as atoms via a new scan_prefix_binary_end helper that walks the lookahead recursively — this is needed for shapes like h +a +b c (two back-to-back prefix-binop args). Recursion is bounded because each step consumes at least one operator + one atom.

2. tests + example: pin prefix-binop call-arg behaviour across engines — 15 cross-engine regression tests covering the canonical repro, 3-arg user functions with prefix-binops in each position, nested h +a +b c, real infix on a call result still parsing as (f a) + b, guard expressions, and a characterisation test for the f +x single-atom-after-operator shape. examples/prefix-arg.ilo demonstrates the now-allowed pattern with two distinct run:/out: cases that exercise the prefix arithmetic at both ends of a list.

Test plan

• cargo test --release --features cranelift — full suite green (baseline 3419 + 15 new = 3434)
• cargo fmt --all -- --check clean
• cargo clippy --all-targets --features cranelift -- -D warnings clean
• All four canonical doc-cited shapes now parse correctly across tree, vm, cranelift
• Real infix (f a + b) still parses as BinOp(Add, Call(f, a), b) — no regression
• Code-reviewed by subagent; the looks_like_prefix_binary shallow-counting gap (nested prefix-binops) was caught and fixed before commit

Follow-ups

• Function-as-arg variant (prnt str nc → prnt(str(nc)), flr +*n 0.25 etc) — needs the parser to know callee arities at parse time. Different fix shape than this PR. Separate design decision (symbol-table lookup vs required parens).
• Multi-fn single-line parsing quirk (two function declarations separated by ; can swallow the second's return type into the first's body) — surfaced while writing tests; flagged as a // FOLLOW-UP: line in tests/regression_prefix_arg_depth.rs.

[codecov]

Codecov Report

❌ Patch coverage is 66.66667% with 4 lines in your changes missing coverage. Please review.
✅ All tests successful. No failed tests found.

Files with missing lines	Patch %	Lines
src/parser/mod.rs	66.66%	4 Missing ⚠️

📢 Thoughts on this report? Let us know!