merge: integration of bug #110/#116/#100 + feat #079/#082 + build profile

- fix #110 (in lake-frontend dev): lone wildcard ret-branch keeps arity 1.
- fix #116 + #100: rt_write_async user_data=0 (fire-and-forget) — no
  more io_parked corruption from never-parked write actors.
- feat #079: dense small-domain when emits a .rodata k-table with
  bounds-checked load instead of N-way switch.
- feat #082: per-actor SCRATCH_RING in ExecCtx + rt_scratch_buf
  pool (SIZE 80→208).
- build: [profile.release] incremental=true + new release-fast
  profile for dev iteration.

Author: morphqdd

Cargo.toml

@@ -30,3 +30,21 @@ tempfile = "3.24.0"
 [build-dependencies]
 anyhow = "1.0.100"
 
+# Nightly-only: incremental compilation in release mode.  Cuts
+# repeat-build time 5-10× when only a small slice of lake-frontend
+# or src/ changes.  Costs ~5% on first build + a bit of disk.
+[profile.release]
+incremental = true
+
+# Fast iteration profile.  Same correctness as release, lower codegen
+# effort.  Use `cargo build --profile release-fast` /
+# `cargo test --profile release-fast` for dev loops; benchmarks
+# and shipping builds keep the plain `--release` profile.
+[profile.release-fast]
+inherits = "release"
+opt-level = 1
+codegen-units = 256
+lto = false
+debug-assertions = false
+overflow-checks = false
+

src/compiler/ctx/rt_funcs.rs

@@ -20,6 +20,7 @@ pub struct RtFuncs {
     pub allocate: FuncId,
     pub allocate_raw: FuncId,
     pub free: FuncId,
+    pub scratch_buf: FuncId,
 }
 
 impl RtFuncs {
@@ -36,6 +37,7 @@ impl RtFuncs {
             allocate: resolve_func(module, "rt_allocate")?,
             allocate_raw: resolve_func(module, "rt_allocate_raw")?,
             free: resolve_func(module, "rt_free")?,
+            scratch_buf: resolve_func(module, "rt_scratch_buf")?,
         })
     }
 
@@ -89,6 +91,15 @@ impl RtFuncs {
     pub fn free_ref(&self, module: &mut ObjectModule, builder: &mut FunctionBuilder) -> FuncRef {
         module.declare_func_in_func(self.free, builder.func)
     }
+
+    /// Per-actor scratch buffer pool — see feature #082.
+    pub fn scratch_buf_ref(
+        &self,
+        module: &mut ObjectModule,
+        builder: &mut FunctionBuilder,
+    ) -> FuncRef {
+        module.declare_func_in_func(self.scratch_buf, builder.func)
+    }
 }
 
 fn resolve_func(module: &ObjectModule, name: &str) -> Result<FuncId> {

src/compiler/pipeline/expr/when_expr.rs

@@ -17,6 +17,153 @@ use crate::compiler::{
 
 use super::{BranchState, compile_expr};
 
+/// Feature #079 — K-table lookup for dense small-domain numeric `when`.
+/// See docs/state/features/079_*.md.
+fn const_fold_i64(expr: &Expr<'_>) -> Option<i64> {
+    match expr {
+        Expr::Num(s, _) => lake_frontend::api::expr::parse_int_literal(s).ok(),
+        Expr::Bool(b) => Some(if *b { 1 } else { 0 }),
+        Expr::Neg(inner) => const_fold_i64(&inner.inner).map(|v| v.wrapping_neg()),
+        Expr::Add(l, r) => Some(const_fold_i64(&l.inner)?.wrapping_add(const_fold_i64(&r.inner)?)),
+        Expr::Sub(l, r) => Some(const_fold_i64(&l.inner)?.wrapping_sub(const_fold_i64(&r.inner)?)),
+        Expr::Mul(l, r) => Some(const_fold_i64(&l.inner)?.wrapping_mul(const_fold_i64(&r.inner)?)),
+        Expr::Div(l, r) => {
+            let rv = const_fold_i64(&r.inner)?;
+            if rv == 0 {
+                None
+            } else {
+                Some(const_fold_i64(&l.inner)?.wrapping_div(rv))
+            }
+        }
+        Expr::BAnd(l, r) => Some(const_fold_i64(&l.inner)? & const_fold_i64(&r.inner)?),
+        Expr::BOr(l, r) => Some(const_fold_i64(&l.inner)? | const_fold_i64(&r.inner)?),
+        Expr::BXor(l, r) => Some(const_fold_i64(&l.inner)? ^ const_fold_i64(&r.inner)?),
+        Expr::Shl(l, r) => {
+            let rv = const_fold_i64(&r.inner)?;
+            if !(0..64).contains(&rv) {
+                None
+            } else {
+                Some(const_fold_i64(&l.inner)?.wrapping_shl(rv as u32))
+            }
+        }
+        Expr::Shr(l, r) => {
+            let rv = const_fold_i64(&r.inner)?;
+            if !(0..64).contains(&rv) {
+                None
+            } else {
+                Some((const_fold_i64(&l.inner)? as u64).wrapping_shr(rv as u32) as i64)
+            }
+        }
+        _ => None,
+    }
+}
+
+/// Detector: returns `Some(values)` iff every arm key is an i64 `Num`,
+/// keys form exactly `0..N`, no wildcard, and every arm body is one
+/// const-foldable i64 expression.
+fn try_build_k_table<'a>(branches: &[(Expr<'a>, Vec<Expr<'a>>)]) -> Option<Vec<i64>> {
+    if branches.len() < 2 {
+        return None;
+    }
+    let n = branches.len() as i64;
+    let mut values = vec![0i64; branches.len()];
+    let mut seen = vec![false; branches.len()];
+    for (cond, body) in branches.iter() {
+        if is_wildcard(cond) {
+            return None;
+        }
+        let key = match cond {
+            Expr::Num(s, _) => lake_frontend::api::expr::parse_int_literal(s).ok()?,
+            _ => return None,
+        };
+        if !(0..n).contains(&key) {
+            return None;
+        }
+        let idx = key as usize;
+        if seen[idx] {
+            return None;
+        }
+        seen[idx] = true;
+        if body.len() != 1 {
+            return None;
+        }
+        values[idx] = const_fold_i64(&body[0])?;
+    }
+    if !seen.iter().all(|&s| s) {
+        return None;
+    }
+    Some(values)
+}
+
+/// Emit the K-table lookup path.  Assumes the discriminant has already
+/// been compiled and lands at `disc_done_id`.  Returns the `after_when_id`
+/// to use as the continuation point.
+fn emit_k_table(
+    ctx: &mut CompilerCtx,
+    builder: &mut FunctionBuilder,
+    machine_ctx_var: Variable,
+    outer_switch: &mut Switch,
+    disc_done_id: i64,
+    values: &[i64],
+) -> Result<i64> {
+    let ptr_ty = ctx.module().target_config().pointer_type();
+    let after_when_id = disc_done_id + 1;
+    let n = values.len() as i64;
+
+    // Declare a Local .rodata symbol holding the i64 table.
+    let data_name = format!("ktbl_{disc_done_id}");
+    let data_id = ctx
+        .module_mut()
+        .declare_data(&data_name, Linkage::Local, false, false)?;
+    let mut bytes: Vec<u8> = Vec::with_capacity(values.len() * 8);
+    for v in values {
+        bytes.extend_from_slice(&v.to_le_bytes());
+    }
+    let mut desc = DataDescription::new();
+    desc.define(bytes.into_boxed_slice());
+    ctx.module_mut().define_data(data_id, &desc)?;
+
+    let b_lookup = builder.create_block();
+    let b_inrange = builder.create_block();
+    let b_oob = builder.create_block();
+
+    // Lookup block — load disc from TEMP_VAL, bounds-check, branch.
+    // Block sealing is deferred to `seal_all_blocks()` at the end of
+    // machine compilation: sealing locally with zero predecessors
+    // (the branch_switch jumps to b_lookup get added later) would
+    // make `use_var(machine_ctx_var)` resolve to undef (0) because
+    // the SSA reconstruction can't see backward through the not-yet
+    // -emitted switch.
+    builder.switch_to_block(b_lookup);
+    let exec_start = ctx.exec_start(builder, machine_ctx_var);
+    let disc = ExecCtxLayout::load(builder, ptr_ty, exec_start, ExecCtxLayout::TEMP_VAL);
+    let in_range = builder.ins().icmp_imm(IntCC::UnsignedLessThan, disc, n);
+    builder.ins().brif(in_range, b_inrange, &[], b_oob, &[]);
+
+    // In-range: load values[disc], store to TEMP_VAL, continue.
+    builder.switch_to_block(b_inrange);
+    let kt_gv = ctx
+        .module_mut()
+        .declare_data_in_func(data_id, builder.func);
+    let kt_base = builder.ins().global_value(ptr_ty, kt_gv);
+    let off = builder.ins().imul_imm(disc, 8);
+    let addr = builder.ins().iadd(kt_base, off);
+    let val = builder.ins().load(ptr_ty, MemFlags::trusted(), addr, 0);
+    let exec_start2 = ctx.exec_start(builder, machine_ctx_var);
+    ExecCtxLayout::store(builder, val, exec_start2, ExecCtxLayout::TEMP_VAL);
+    let qb = ctx.quantum_block();
+    let after_v = builder.ins().iconst(ptr_ty, after_when_id);
+    builder.ins().jump(qb, &[BlockArg::Value(after_v)]);
+
+    // OOB: silent fall-through, matches when_no_match_continues semantics.
+    builder.switch_to_block(b_oob);
+    let after_v2 = builder.ins().iconst(ptr_ty, after_when_id);
+    builder.ins().jump(qb, &[BlockArg::Value(after_v2)]);
+
+    outer_switch.set_entry(disc_done_id as u128, b_lookup);
+    Ok(after_when_id)
+}
+
 enum WhenBranchType {
     Simple,
     Ptr,
@@ -59,6 +206,36 @@ pub fn compile<'a>(
         positions.into_iter().next()
     };
 
+    // #079 — Detect the K-table fast path BEFORE creating the
+    // N-way-switch helper blocks: those blocks would otherwise be
+    // dangling (created but never filled) when we return early.
+    if let Some(values) = try_build_k_table(&branches) {
+        let disc_done_id = match compile_expr(
+            ctx,
+            builder,
+            machine_ctx_var,
+            block_id,
+            outer_switch,
+            state,
+            cond_expr,
+            None,
+            None,
+            false,
+        )? {
+            StmtOutcome::Continue(id) => id,
+            other => bail!("`when` discriminant cannot be a terminal: {:?}", other),
+        };
+        let after_when_id = emit_k_table(
+            ctx,
+            builder,
+            machine_ctx_var,
+            outer_switch,
+            disc_done_id,
+            &values,
+        )?;
+        return Ok(StmtOutcome::Continue(after_when_id));
+    }
+
     let b_check = builder.create_block();
     let b_ret: Vec<_> = (0..branches.len())
         .map(|_| builder.create_block())

src/compiler/rt/funcs/io_uring.rs

@@ -621,29 +621,10 @@ pub fn define_write_async(mut ctx: CompilerCtx) -> Result<CompilerCtx> {
         .ins()
         .store(MemFlags::trusted(), len32, sqe_addr, 24);
 
-    // user_data @ 32 (u64) = current proc-ctx fat-ptr.  Echoed verbatim in
-    // the CQE, used by `emit_wake_by_user_data` to wake the right actor.
-    let cur_idx = builder.ins().load(
-        ty,
-        MemFlags::trusted(),
-        sh_ctx_start,
-        ShedulerCtxLayout::CURRENT_PROCESS,
-    );
-    let proc_arr_fat_for_ud = builder.ins().load(
-        ty,
-        MemFlags::trusted(),
-        sh_ctx_start,
-        ShedulerCtxLayout::PROCESS_ARR_FAT,
-    );
-    let proc_arr_start_for_ud = builder
-        .ins()
-        .load(ty, MemFlags::trusted(), proc_arr_fat_for_ud, 0);
-    let cur_off = builder.ins().ishl_imm(cur_idx, 3);
-    let cur_addr = builder.ins().iadd(proc_arr_start_for_ud, cur_off);
-    let cur_proc_ctx = builder.ins().load(ty, MemFlags::trusted(), cur_addr, 0);
+    // user_data=0: rt_write_async is fire-and-forget. See docs/state/bugs/116_spawned_print_lost.md
     builder
         .ins()
-        .store(MemFlags::trusted(), cur_proc_ctx, sqe_addr, 32);
+        .store(MemFlags::trusted(), zero64, sqe_addr, 32);
 
     // SQ.array[idx] = idx — the indirect submission queue.
     let arr_offset = builder.ins().ishl_imm(idx, 2);

src/compiler/rt/funcs/mod.rs

@@ -5,6 +5,7 @@ pub mod exit;
 pub mod io_uring;
 pub mod mmap;
 pub mod read;
+pub mod scratch;
 pub mod strings;
 pub mod syscall;
 pub mod write;