perf(codegen): inline captureless some loop; codegen-time module-const literal fold (ECS round 4, +5.2%)

changelog.d/8933-inline-some-const-fold.md

@@ -0,0 +1,2 @@
+- **codegen:** `arr.some(capturelessArrow)` runs as an inline loop with a direct call of the arrow's body (rooted receiver re-read per element, forwarded heads through the new `js_array_live_head`, holes skipped, `true`/`false` decided inline); `js_array_some_captureless` stays the fallback for receivers the loop does not admit.
+- **driver:** module-level `const` literals (`export const MAX = 1023`) fold into their reads after the whole transform phase and before codegen, so one-line predicates comparing against them earn their typed clones without changing any cross-module inlining decision. `codehz/ecs` "5k entities: 3 commands each + sync": +3.7% and +1.5% (15/15 paired runs each).

crates/perry-codegen/src/expr/array_callback_shape_tests.rs

@@ -214,6 +214,19 @@ fn captureless_inline_some_passes_the_callback_body_directly() {
             && ir.contains("ptr @perry_closure_array_some_captureless_ts__99"),
         "a captureless inline arrow should pass its body symbol directly:\n{ir}"
     );
+    // The admitted receiver runs the loop inline: the arrow's body is a direct
+    // call (a null closure, then as many of element/index/receiver as it
+    // declares — one here), a hole skips, a `true` result exits without a
+    // truthiness call, and the runtime helper above is only the fallback.
+    assert!(
+        ir.contains("some.inline.loop")
+            && ir.contains(
+                "call double @perry_closure_array_some_captureless_ts__99(i64 0, double "
+            )
+            && ir.contains("call i64 @js_array_live_head(")
+            && ir.contains("call i32 @js_is_truthy("),
+        "the captureless some loop should run inline with the direct body call:\n{ir}"
+    );
     assert!(
         !ir.contains("call i64 @js_closure_alloc_singleton")
             && !ir.contains("call double @js_array_some("),

crates/perry-codegen/src/expr/logical_collections.rs

@@ -76,6 +76,240 @@ fn is_static_number_key_map(ctx: &FnCtx<'_>, map: &Expr) -> bool {
 /// cannot be observed by `Array.prototype.some` and whose body cannot inspect
 /// a closure environment. The runtime may then invoke the code pointer
 /// directly without allocating/looking up a singleton ClosureHeader.
+/// `arr.some(capturelessArrow)` as an inline loop, with `js_array_some_captureless`
+/// as the fallback for every receiver the loop does not admit.
+///
+/// The runtime helper decides the receiver ONCE — a plain `GC_TYPE_ARRAY`
+/// head, no indexed descriptors, pristine `Array.prototype` /
+/// `Object.prototype` index state, `length <= capacity` — and then runs the
+/// element loop with one rooted re-resolution per element, a NaN-boxed
+/// receiver per call and an indirect call through the function pointer. The
+/// loop emitted here makes the same one-time decision on the same live bits
+/// (the sticky `PERRY_ARRAY_INDEX_FAST_PATH_INVALIDATED` byte is the
+/// prototype half), then per element: re-reads the head from its root (the
+/// callback may have collected, or grown the array — a forwarded head goes
+/// through `js_array_live_head`), skips indices past the live length and
+/// holes, calls the arrow's body symbol directly with as many of
+/// `(element, index, receiver)` as it declares, and decides `true` / `false`
+/// results inline with `js_is_truthy` for anything else. Same contract as
+/// the helper: the bound is the length at entry, holes are skipped, an
+/// exotic or non-array receiver takes the helper.
+fn lower_captureless_some_inline(
+    ctx: &mut FnCtx<'_>,
+    array: &Expr,
+    callback_func: &str,
+    param_count: usize,
+) -> Result<String> {
+    use crate::nanbox::{POINTER_TAG_TOP16_I64, TAG_HOLE_I64};
+    use crate::types::{I1, I16, I8};
+    const TAG_TRUE_I64: &str = "9222246136947933188"; // 0x7FFC_0000_0000_0004
+    const TAG_FALSE_I64: &str = "9222246136947933187"; // 0x7FFC_0000_0000_0003
+    rooting::with_rooted_group(ctx, 1, |ctx, group| {
+        let arr_idx = group.lower(ctx, array, true)?;
+        let arr_box0 = group.reread(ctx, arr_idx)?;
+        let admit_idx = ctx.new_block("some.inline.admit");
+        let loop_idx = ctx.new_block("some.inline.loop");
+        let body_idx = ctx.new_block("some.inline.body");
+        let resolve_idx = ctx.new_block("some.inline.resolve");
+        let live_idx = ctx.new_block("some.inline.live");
+        let elem_idx = ctx.new_block("some.inline.elem");
+        let call_idx = ctx.new_block("some.inline.call");
+        let slow_idx = ctx.new_block("some.inline.slow");
+        let truthy_idx = ctx.new_block("some.inline.truthy");
+        let next_idx = ctx.new_block("some.inline.next");
+        let found_idx = ctx.new_block("some.inline.found");
+        let fallback_idx = ctx.new_block("some.inline.fallback");
+        let merge_idx = ctx.new_block("some.inline.merge");
+        let admit_l = ctx.block_label(admit_idx);
+        let loop_l = ctx.block_label(loop_idx);
+        let body_l = ctx.block_label(body_idx);
+        let resolve_l = ctx.block_label(resolve_idx);
+        let live_l = ctx.block_label(live_idx);
+        let elem_l = ctx.block_label(elem_idx);
+        let call_l = ctx.block_label(call_idx);
+        let slow_l = ctx.block_label(slow_idx);
+        let truthy_l = ctx.block_label(truthy_idx);
+        let next_l = ctx.block_label(next_idx);
+        let found_l = ctx.block_label(found_idx);
+        let fallback_l = ctx.block_label(fallback_idx);
+        let merge_l = ctx.block_label(merge_idx);
+        let counter = ctx.func.alloca_entry(I32);
+
+        // A heap pointer, before any header is read.
+        {
+            let blk = ctx.block();
+            let bits = blk.bitcast_double_to_i64(&arr_box0);
+            let top16 = blk.lshr(I64, &bits, "48");
+            let is_pointer = blk.icmp_eq(I64, &top16, POINTER_TAG_TOP16_I64);
+            blk.cond_br(&is_pointer, &admit_l, &fallback_l);
+        }
+        // Admission: the helper's one-time decision, on the live bits.
+        ctx.current_block = admit_idx;
+        let len0 = {
+            let blk = ctx.block();
+            let raw = unbox_to_i64(blk, &arr_box0);
+            let type_addr = blk.sub(I64, &raw, "8");
+            let type_ptr = blk.inttoptr(I64, &type_addr);
+            let obj_type = blk.load(I8, &type_ptr);
+            let is_array = blk.icmp_eq(I8, &obj_type, "1"); // GC_TYPE_ARRAY
+            let flags_addr = blk.sub(I64, &raw, "7");
+            let flags_ptr = blk.inttoptr(I64, &flags_addr);
+            let gc_flags = blk.load(I8, &flags_ptr);
+            let forwarded = blk.and(I8, &gc_flags, "128"); // GC_FLAG_FORWARDED
+            let not_forwarded = blk.icmp_eq(I8, &forwarded, "0");
+            let reserved_addr = blk.sub(I64, &raw, "6");
+            let reserved_ptr = blk.inttoptr(I64, &reserved_addr);
+            let reserved = blk.load(I16, &reserved_ptr);
+            let descriptors = blk.and(I16, &reserved, "1024"); // OBJ_FLAG_ARRAY_DESCRIPTORS
+            let no_descriptors = blk.icmp_eq(I16, &descriptors, "0");
+            let invalidated = blk.load_volatile(I8, "@PERRY_ARRAY_INDEX_FAST_PATH_INVALIDATED");
+            let prototype_clean = blk.icmp_eq(I8, &invalidated, "0");
+            let len_ptr = blk.inttoptr(I64, &raw);
+            let length = blk.load(I32, &len_ptr);
+            let cap_addr = blk.add(I64, &raw, "4");
+            let cap_ptr = blk.inttoptr(I64, &cap_addr);
+            let capacity = blk.load(I32, &cap_ptr);
+            let dense = blk.icmp_ule(I32, &length, &capacity);
+            let a = blk.and(I1, &is_array, &not_forwarded);
+            let b = blk.and(I1, &a, &no_descriptors);
+            let c = blk.and(I1, &b, &prototype_clean);
+            let admitted = blk.and(I1, &c, &dense);
+            blk.store(I32, "0", &counter);
+            blk.cond_br(&admitted, &loop_l, &fallback_l);
+            length
+        };
+        // loop: i < len0 ? (the bound is the length at entry)
+        ctx.current_block = loop_idx;
+        let false_box = {
+            let blk = ctx.block();
+            let i = blk.load(I32, &counter);
+            let more = blk.icmp_ult(I32, &i, &len0);
+            // The merge phi's operands are materialised in the predecessors:
+            // a phi must lead its block.
+            let false_box = blk.bitcast_i64_to_double(TAG_FALSE_I64);
+            blk.cond_br(&more, &body_l, &merge_l);
+            false_box
+        };
+        // body: re-read the head from its root; a forwarded head resolves.
+        ctx.current_block = body_idx;
+        let arr_box = group.reread(ctx, arr_idx)?;
+        let raw_reread = {
+            let blk = ctx.block();
+            let raw = unbox_to_i64(blk, &arr_box);
+            let flags_addr = blk.sub(I64, &raw, "7");
+            let flags_ptr = blk.inttoptr(I64, &flags_addr);
+            let gc_flags = blk.load(I8, &flags_ptr);
+            let forwarded = blk.and(I8, &gc_flags, "128");
+            let is_forwarded = blk.icmp_ne(I8, &forwarded, "0");
+            blk.cond_br(&is_forwarded, &resolve_l, &live_l);
+            raw
+        };
+        ctx.current_block = resolve_idx;
+        let resolved = ctx
+            .block()
+            .call(I64, "js_array_live_head", &[(I64, &raw_reread)]);
+        ctx.block().br(&live_l);
+        // live: bounds against the live length, then the element.
+        ctx.current_block = live_idx;
+        let raw = ctx
+            .block()
+            .phi(I64, &[(&raw_reread, &body_l), (&resolved, &resolve_l)]);
+        let i = {
+            let blk = ctx.block();
+            let i = blk.load(I32, &counter);
+            let len_ptr = blk.inttoptr(I64, &raw);
+            let live_len = blk.load(I32, &len_ptr);
+            let in_range = blk.icmp_ult(I32, &i, &live_len);
+            blk.cond_br(&in_range, &elem_l, &next_l);
+            i
+        };
+        ctx.current_block = elem_idx;
+        let elem_bits = {
+            let blk = ctx.block();
+            let i64_i = blk.zext(I32, &i, I64);
+            let byte_offset = blk.shl(I64, &i64_i, "3");
+            let with_header = blk.add(I64, &byte_offset, "8");
+            let elem_addr = blk.add(I64, &raw, &with_header);
+            let elem_ptr = blk.inttoptr(I64, &elem_addr);
+            let bits = blk.load(I64, &elem_ptr);
+            let is_hole = blk.icmp_eq(I64, &bits, TAG_HOLE_I64);
+            blk.cond_br(&is_hole, &next_l, &call_l);
+            bits
+        };
+        ctx.current_block = call_idx;
+        let result = {
+            let blk = ctx.block();
+            let elem = blk.bitcast_i64_to_double(&elem_bits);
+            let i_double = blk.uitofp(I32, &i, DOUBLE);
+            let recv = nanbox_pointer_inline(blk, &raw);
+            let mut args: Vec<(crate::types::LlvmType, &str)> =
+                vec![(I64, "0"), (DOUBLE, elem.as_str())];
+            if param_count >= 2 {
+                args.push((DOUBLE, i_double.as_str()));
+            }
+            if param_count >= 3 {
+                args.push((DOUBLE, recv.as_str()));
+            }
+            let result = blk.call(DOUBLE, callback_func.trim_start_matches('@'), &args);
+            let bits = blk.bitcast_double_to_i64(&result);
+            let is_true = blk.icmp_eq(I64, &bits, TAG_TRUE_I64);
+            blk.cond_br(&is_true, &found_l, &slow_l);
+            result
+        };
+        ctx.current_block = slow_idx;
+        {
+            let blk = ctx.block();
+            let bits = blk.bitcast_double_to_i64(&result);
+            let is_false = blk.icmp_eq(I64, &bits, TAG_FALSE_I64);
+            blk.cond_br(&is_false, &next_l, &truthy_l);
+        }
+        ctx.current_block = truthy_idx;
+        {
+            let blk = ctx.block();
+            let truthy = blk.call(I32, "js_is_truthy", &[(DOUBLE, &result)]);
+            let nonzero = blk.icmp_ne(I32, &truthy, "0");
+            blk.cond_br(&nonzero, &found_l, &next_l);
+        }
+        ctx.current_block = next_idx;
+        {
+            let blk = ctx.block();
+            let i = blk.load(I32, &counter);
+            let inc = blk.add(I32, &i, "1");
+            blk.store(I32, &inc, &counter);
+            blk.br(&loop_l);
+        }
+        ctx.current_block = found_idx;
+        let true_box = {
+            let blk = ctx.block();
+            let true_box = blk.bitcast_i64_to_double(TAG_TRUE_I64);
+            blk.br(&merge_l);
+            true_box
+        };
+        ctx.current_block = fallback_idx;
+        let fallback_value = {
+            let blk = ctx.block();
+            let arr_handle = unbox_to_i64(blk, &arr_box0);
+            let value = blk.call(
+                DOUBLE,
+                "js_array_some_captureless",
+                &[(I64, &arr_handle), (PTR, callback_func)],
+            );
+            blk.br(&merge_l);
+            value
+        };
+        ctx.current_block = merge_idx;
+        let blk = ctx.block();
+        Ok(blk.phi(
+            DOUBLE,
+            &[
+                (&false_box, &loop_l),
+                (&true_box, &found_l),
+                (&fallback_value, &fallback_l),
+            ],
+        ))
+    })
+}
+
 fn captureless_some_callback(ctx: &FnCtx<'_>, callback: &Expr) -> Option<String> {
     let Expr::Closure {
         func_id,
@@ -346,13 +580,10 @@ pub(crate) fn lower(ctx: &mut FnCtx<'_>, expr: &Expr) -> Result<String> {
         // so we forward it directly without conversion.
         Expr::ArraySome { array, callback } => {
             if let Some(callback_func) = captureless_some_callback(ctx, callback) {
-                let arr_box = lower_expr(ctx, array)?;
-                let arr_handle = unbox_to_i64(ctx.block(), &arr_box);
-                return Ok(ctx.block().call(
-                    DOUBLE,
-                    "js_array_some_captureless",
-                    &[(I64, &arr_handle), (PTR, &callback_func)],
-                ));
+                let Expr::Closure { params, .. } = callback.as_ref() else {
+                    unreachable!("captureless_some_callback matched a closure");
+                };
+                return lower_captureless_some_inline(ctx, array, &callback_func, params.len());
             }
             // #7615 slice 2: same callback window as `ArrayFilter` above.
             rooting::with_operands_rooted(ctx, &[array, callback], |ctx, vals| {

crates/perry-codegen/src/gc_call_effects.rs

@@ -157,6 +157,9 @@ pub(crate) fn classify_direct_callee(name: &str) -> GcCallEffect {
         // side-table remove `layout_init_pointer_free` already does on every
         // allocation. No Perry allocation, no re-entry into generated code.
         | "js_array_declare_all_pointer_elements"
+        // `clean_arr_ptr` on a raw head: reads headers and the forwarding
+        // registry, allocates nothing, never re-enters generated code.
+        | "js_array_live_head"
         // TLS dynamic-call context only. #8596 adds the `_get` reader — a bare
         // `IMPLICIT_THIS.with(|c| f64::from_bits(c.get()))` (`object/this_binding.rs`),
         // the exact shape of the already-admitted `_set` and `js_new_target_get`.

crates/perry-codegen/src/root_reload.rs

@@ -234,6 +234,7 @@ const NON_COLLECTING: &[&str] = &[
     "js_tdz_suppress_end",
     "js_array_note_numeric_write",
     "js_array_declare_all_pointer_elements",
+    "js_array_live_head",
     "js_array_length",
     "js_object_mark_class",
     "js_class_object_pin_parent",

crates/perry-codegen/src/runtime_decls/arrays.rs

@@ -173,6 +173,9 @@ pub fn declare_phase_b_arrays(module: &mut LlModule) {
     //   js_gc_init_typed_shape_layout(obj: u64, slot_count: u32, raw_f64_mask_words: *const u64, raw_f64_mask_word_count: u32, pointer_mask_words: *const u64, pointer_mask_word_count: u32)
     module.declare_function("js_write_barrier", VOID, &[I64, I64]);
     module.declare_function("js_write_barrier_slot", VOID, &[I64, I64, I64]);
+    // perry-runtime: `array::indexing_support::js_array_live_head` — resolves a
+    // forwarded array head a generated loop re-read from its root.
+    module.declare_function("js_array_live_head", I64, &[I64]);
     module.declare_function(
         "js_write_barrier_slot_validated_parent",
         VOID,

crates/perry-runtime/src/array/indexing_support.rs

@@ -6,6 +6,16 @@
 use super::*;
 use std::sync::atomic::{AtomicBool, AtomicU8, Ordering};
 
+/// Resolve a raw array head a generated loop re-read from its root after a
+/// callback returned: the callback may have grown the array, leaving the root
+/// on a forwarding stub. Pure `clean_arr_ptr`; null for anything that is not
+/// an array. Generated `some` loops call this only when the re-read head's
+/// header carries `GC_FLAG_FORWARDED`.
+#[no_mangle]
+pub extern "C" fn js_array_live_head(arr: i64) -> i64 {
+    clean_arr_ptr(arr as *const ArrayHeader) as i64
+}
+
 /// A strict-mode element write (`arr[i] = v`) to a **frozen** array's existing
 /// index is `[[Set]]` on a non-writable data property with `Throw = true`
 /// (ECMA-262 §10.4.2.4 → OrdinarySetWithOwnDescriptor step 2.b.i), so it must

crates/perry-transform/src/closure_local_inline.rs

@@ -529,7 +529,7 @@ fn for_each_expr_in_stmt(stmt: &Stmt, f: &mut dyn FnMut(&Expr)) {
     }
 }
 
-fn for_each_expr_in_stmt_mut(stmt: &mut Stmt, f: &mut dyn FnMut(&mut Expr)) {
+pub(crate) fn for_each_expr_in_stmt_mut(stmt: &mut Stmt, f: &mut dyn FnMut(&mut Expr)) {
     match stmt {
         Stmt::Let { init, .. } => {
             if let Some(e) = init {

crates/perry-transform/src/lib.rs

@@ -16,6 +16,7 @@ pub mod finally_inline;
 pub mod generator;
 pub mod i18n;
 pub mod inline;
+pub mod module_const_fold;
 pub mod prop_cse;
 mod source_spans;
 pub mod state_desugar;