linq_fold: trivial-let elision + reverse_take skip-into-tail — closes the m4 ladder

[borisbat]

Two slices that close the last m4-vs-m3f outliers from #2824's bench snapshot. Wraps the m4 perf push before docs / tutorials.

Slice 1 — trivial-let elision

Closes: sum_aggregate_m4 1.3ns systemic gap vs m3f.

When _select(_.userName) peels to a single decs_tup.<field> reference, rename the chain bind directly to the corresponding iter var instead of synthesizing decs_sel_N. wrap_decs_chain skips emitting let decs_sel_N = car_price entirely; the action's acc += <iterVar> references the iter var natively.

Required extending DecsTupUsageScanner with an iter-var → user-name reverse map so bare iter-var refs still seed the pruner (previously: empty usedNames fell through to unpruned-default, defeating the elision).

Slice 2 — reverse_take skip-into-tail

Closes: reverse_take_m4 48 → 9.2 ns/op (5.2× win, allocs 42B → 1B).

For from_decs_template(...).reverse().take(N).to_array() with no where/select, emit a two-pass invoke:

1. Pass 1 — sum arch.size across archetypes (no entity load, just archetype-header walk)
2. Pass 2 — for_each_archetype_find skips whole archetypes whose cumulative size still fits below skip = total - N; the partial archetype uses a per-iter skip-counter; once the takeN-sized buffer fills, return true stops iteration across remaining archetypes
3. reverse_inplace runs on the small N buffer at end, not the full source

where/select fall through to the legacy buffer + reverse_inplace + resize emit unchanged — a where filter invalidates the size-based skip (count after filter is unknown without iterating).

Bench results (INTERP, 100K rows, ns/op)

Lane	Before	After	Delta	m3f
sum_aggregate_m4	3.4	2.1	-1.3	2.1
reverse_take_m4	48.0	9.2	-38.8	0.0
select_where_sum_m4	7.5	7.5	0.0	7.5
contains_match_m4	2.1	1.4	-0.7	2.2
chained_where_m4	6.6	6.6	0.0	6.6
count_aggregate_m4	4.1	4.1	0.0	4.1

sum_aggregate_m4 now matches m3f exactly. reverse_take_m4 doesn't hit m3f's 0.0 (m3f leverages array-side R6 backward-index access, which decs can't replicate without indexed-component-array helpers) but the skip-into-tail cuts the remaining cost to just the per-element iter ticks. contains_match_m4 beats m3f at 2.2.

Tests

• test_unroll_select_sum_trivial_let_elision_splice_shape — asserts decs_sel does not appear in _select(_.val).sum() splice body
• test_unroll_where_select_sum_trivial_let_elision_splice_shape — same elision after a _where filter
• test_unroll5d_reverse_take_skip_into_tail_splice_shape — asserts for_each_archetype_find count + presence of decs_skips skip-counter local
• test_reverse_take_multi_archetype_parity — exercises whole-archetype-skip + partial-archetype skip-counter
• test_reverse_take_skip_zero_when_take_exceeds_total — actualTake = totalCount branch (early-exit doesn't fire)
• test_reverse_take_empty_source — totalCount = 0 early-return before for_each_archetype_find

Verification

• 1388/1388 linq + 245/245 decs + 782/782 dasSQLITE green INTERP
• MCP lint + CI-style lint both clean
• AOT lane (and JIT) deferred to CI

Out of scope

• Closing the residual reverse_take 9.2 ns/op gap vs m3f's 0.0 would require either an indexed-component-array helper (so the inner for can start at an arbitrary offset, skipping iter ticks too) or moving the skip math into decs itself. Separate slice if it ever matters in production.
• select is included in the skip-into-tail bail. It only affects element shape, not count, so it could in principle stay on the fast path — but the v1 emit doesn't carry projection through the inner-for body. Easy follow-up.

🤖 Generated with Claude Code

[Copilot]

Pull request overview

This PR tightens the decs (m4) linq-fold unroll path to close remaining performance outliers versus the array (m3f) lane, focusing on eliminating redundant binds in trivial projections and adding a specialized fast path for reverse().take(N).to_array().

Changes:

• Add “trivial-let elision” so single-field _select(_.field) projections can reuse the underlying iter var directly and avoid emitting no-op decs_sel_* bindings; extend decs tuple usage scanning to recognize bare iter-var usage so pruning still works.
• Add a two-pass reverse().take(N).to_array() decs fast path that first sums archetype sizes, then skips into the tail using for_each_archetype_find + a per-iter skip counter, and reverses only the small N-sized buffer.
• Add new splice-shape and parity tests covering the new behaviors.

Reviewed changes

Copilot reviewed 2 out of 2 changed files in this pull request and generated 3 comments.

File	Description
daslib/linq_fold.das	Implements trivial-let elision (with updated decs usage scanning) and the reverse+take skip-into-tail fast path in the decs reverse planner.
tests/linq/test_linq_from_decs.das	Adds splice-shape assertions and parity tests intended to validate the new decs unroll optimizations.

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.