linq_fold: plan_decs_unroll — splice from_decs* eager bridge into for_each_archetype

[borisbat]

Summary

New plan_decs_unroll planner in daslib/linq_fold.das. Recognizes the post-expansion from_decs* eager-bridge shape and replaces it with a for_each_archetype walk that hoists the linq accumulator above the per-entity loop — same emission shape query() produces by hand, no to_sequence, no lambda-per-element.

Supersedes #2748 (closes upon merge). The old PR pattern-matched the bridge inner for-loop and emitted per-terminator splices via renameVariable; this rewrite uses a named-tuple bind in the for-body so fold_linq_cond can peel user lambdas naturally (_.fieldname → tup.fieldname), and covers a different terminator set (count/long_count/sum vs count/to_array).

Coverage

Slice 1 — bare count (arch.size shortcut):

• _fold(from_decs*(...).count()) → var acc=0; for_each_archetype $(arch) { acc += arch.size }; return acc. No per-entity walk.

Slice 2 — chain-aware terminators:

• count, long_count, sum
• Chain ops: _where (multiple, AND'd), single _select
• Canonical order only (where before select; chained selects bail to tier-2)

Multi-field bridges supported via named-tuple bind: var tup = (f1=iter1, f2=iter2); <chain body>. User's _.fieldname access resolves to tup.fieldname after fold_linq_cond peels with bound name = tup.

Bails (cascade to tier-2 eager bridge, runs correctly but slower):

• Terminators other than count/long_count/sum: to_array, first, any, contains, min, max, average, distinct, group_by, reverse, order_by
• After-select where, chained selects, take/skip/take_while/skip_while
• Any shape that doesn't match the eager-bridge AST

Benchmarks (interpreter, 100K entities)

variant	ns/entity	vs master
m1 hand-written query() (ideal target)	4	1×
m2 from_decs_template(...).count() (raw)	60	baseline
m2 _fold(from_decs_template(...).count())	0	∞× (arch.size shortcut)
m4 hand-written _where(...)._select(...).sum() raw	202	baseline
m4 _fold(...)._where(...)._select(...)..sum()) BEFORE	63	baseline
m4 _fold(...)._where(...)._select(...)..sum()) AFTER	6	10.5× faster

Architecture

plan_decs_unroll:

1. Recognizer (extract_decs_bridge): pattern-matches invoke($() { var res; for_each_archetype(req, erq, $(arch) { for(iter_vars in get_ro_sources){push(named_tuple)} }); return res.to_sequence() }). Captures req hash, erq factory, arch param name, cloned inner ExprFor, per-field iter names + user names from the push tuple. Verifies to_sequence references the same res. Any mismatch returns null → tier-2 cascade runs the eager bridge unchanged.

2. Bare count shortcut (emit_decs_count_archsize): no per-entity walk; sums arch.size per archetype.

3. Chain-aware emission (emit_decs_accumulator):

   • Walks chain ops, peels user lambdas via fold_linq_cond(lambda, tupName) → projection / where expression in terms of the named tuple.
   • Clones the bridge's inner ExprFor (preserves iter vars + get_ro sources, reuses bridge's archName).
   • Substitutes the for-body with var tup = (n1=iter1, n2=iter2, ...); <wrapped chain body>.
   • Wraps in outer invoke($() : ResultType { var acc = init; for_each_archetype(req, erq) $(arch) { <cloned for> }; return acc }).

Verification

• mcp__daslang__lint daslib/linq_fold.das: clean
• mcp__daslang__lint tests/linq/test_linq_from_decs.das: clean
• tests/linq: 1146/1146 green (interpreter)
• tests/decs: 239/239 green (interpreter)
• New tests: 8 functional parity + 2 AST-shape gates confirming splice fires

Out of scope (follow-ups)

• Slice 3: buffer terminators (to_array), early-exit (first/first_or_default/any/all/contains), min/max/average
• Slice 4: chained selects, after-select where, take/skip/take_while/skip_while chain ops
• Slice 5: state-table terminators (distinct, group_by, reverse, order_by)
• AOT benchmark sweep (defer until full terminator coverage)
• LINQ_TO_DECS.md design-doc refresh

Test plan

• CI green across interpreter + AOT + Release/Debug matrix
• No regression in tests/linq/test_linq_from_decs.das (existing 7 tests) or any other tests/linq + tests/decs
• Splice-shape AST gates fire (verified locally via find_module_function_via_rtti)

🤖 Generated with Claude Code

[Copilot]

Pull request overview

This PR adds a new _fold planner (plan_decs_unroll) to recognize the fully-expanded from_decs* eager-bridge AST shape and replace it with a for_each_archetype-based emission that hoists accumulator work outside the per-entity iterator/to_sequence bridge, enabling much faster count/long_count/sum (with limited _where/single _select) on DECS sources.

Changes:

• Add plan_decs_unroll (plus recognizer + emitters) to splice the from_decs* eager bridge into an archetype walk, including an arch.size shortcut for bare count().
• Extend LINQ-from-DECS tests with new parity checks and AST “splice fired” gates.
• Add two new DECS benchmarks to compare eager-bridge vs _fold splice vs hand-written baselines.

Reviewed changes

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

File	Description
daslib/linq_fold.das	Adds DECS eager-bridge recognition and optimized emission for count/long_count/sum, and wires the planner into the _fold cascade.
tests/linq/test_linq_from_decs.das	Adds new Slice 1/Slice 2 functional parity tests and AST-shape gating for the splice.
benchmarks/decs/bench_from_decs_template_sum.das	Adds benchmark coverage for _where + _select + sum comparing eager bridge vs _fold vs hand-written query.
benchmarks/decs/bench_from_decs_count.das	Adds benchmark coverage for bare count() including the arch.size shortcut target.

---

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

[Copilot]

Pull request overview

Copilot reviewed 4 out of 4 changed files in this pull request and generated no new comments.