Path D: array writes (ArrSetNamed, ArrayIndexAssign) + cross-fn float

RandomCoder-lab · claude · RandomCoder-lab · commit 89c86948c6d8 · 2026-05-15T17:01:50.000-05:00
Adds mutable array writes to the dual-band JIT. Combined with
Path A.4's read support, JIT'd OMC fns can now build, fill, and
read arrays of arbitrary content within a single fn call —
unlocking the build-then-process pattern that most numerical
algorithms use (including the harmonic libraries).

What's new:
- Op::ArrSetNamed(name) handler: optimized form the compiler
  emits for `arr_set(name, idx, val)`. Pops value+index, looks
  up the named array slot, GEPs slot+1 (skip length prefix),
  stores value. Pushes a placeholder (0) on stack so the
  trailing Pop the compiler emits doesn't underflow.
- Op::ArrayIndexAssign(name) handler: same semantics, used for
  `name[idx] = val` syntax. No placeholder push (statement form).
- New helper emit_array_set_named consolidates both. Loads the
  array's pointer from the named slot's &lt;2 x i64&gt;, extracts α
  (the i64-bit-pattern pointer), inttoptr, GEP, store value's α.

Beta semantics on writes: the value's β is discarded. Arrays
hold scalar α only; reads via ArrayIndex splat back into matched
(α, α) bands. This is a deliberate MVP choice — true β tracking
through arrays would need parallel storage or a wider element
type. The "harmonic array" type stays open as future work.

Tests added (3 total):
- jit_array_write_with_arr_set: build squares array via arr_set
  in a loop, verify a known slot
- jit_array_write_then_sum: build squares, then sum them. Verifies
  sum_of_squares(10) = 285, sum_of_squares(5) = 30
- cross_fn_float_passing: documents the structural cross-fn-float
  capability AND its limitation: callee with untyped params emits
  Op::Add (int) on the float bit-pattern, producing wrong values.
  Cross-fn float math today requires explicit conversion at the
  fn boundary via to_int/to_float, OR statically-typed parameters
  in the OMC compiler (which is a separate compiler-side task).

What's still NOT covered:
- Op::ArrPushNamed (dynamic resize): our arrays are stack alloca
  with fixed length-at-NewArray-time. Push would need malloc/realloc
  or pre-allocated capacity. Out of scope for this MVP.
- Op::SafeArrSetNamed (H.5.2 self-healing variant): folds the
  index to nearest Fibonacci attractor and Euclidean-mods by length.
  Unused in the harmonic libs we want to JIT, so deferred.
- Cross-fn float passing where callee untyped: same compiler-side
  story as Path A.2's missing DivFloat — requires the bytecode
  compiler to emit AddFloat/SubFloat/MulFloat when call-site type
  info is available.

Workspace: 41 codegen tests pass (1 IR + 4 cross-fn + 6 arrays
+ 5 dual-band + 5 dispatch + 4 floats + 3 harmony + 5 phi_shadow
+ 8 scalar). Smoke + harmonic-lib + 149 core tests still green.

Co-Authored-By: Claude Opus 4.7 &lt;noreply@anthropic.com&gt;
diff --git a/omnimcode-codegen/src/dual_band.rs b/omnimcode-codegen/src/dual_band.rs
@@ -392,6 +392,31 @@ impl<'ctx, 'a> DualBandLowerer<'ctx, 'a> {
                     let val = self.emit_array_index(arr_v, idx_v, i)?;
                     stack.push(self.splat(val, "aidx_v")?);
                 }
+                // Path D: array writes. ArrSetNamed(name) is the
+                // optimized form the compiler emits for
+                // `arr_set(name, idx, val)` where `name` is a literal
+                // variable. Pops value, pops index, looks up the
+                // array via the named slot, GEPs slot+1, stores.
+                // Pushes a placeholder (0) so the trailing Pop the
+                // compiler emits doesn't underflow — the OMC builtin
+                // arr_set returns null in tree-walk.
+                Op::ArrSetNamed(name) => {
+                    let val_v = self.pop(&mut stack, i, "ArrSetNamed value")?;
+                    let idx_v = self.pop(&mut stack, i, "ArrSetNamed idx")?;
+                    self.emit_array_set_named(name, idx_v, val_v, i)?;
+                    stack.push(self.splat(i64_type.const_int(0, false), "asn_ret")?);
+                }
+                // ArrayIndexAssign(name): the compiler's emit for
+                // `name[idx] = val` syntax. Same semantics as
+                // ArrSetNamed but the bytecode form is value-then-
+                // index-then-op (different stack discipline).
+                // Doesn't push a placeholder (the AST form is a
+                // statement, not an expression).
+                Op::ArrayIndexAssign(name) => {
+                    let val_v = self.pop(&mut stack, i, "ArrayIndexAssign value")?;
+                    let idx_v = self.pop(&mut stack, i, "ArrayIndexAssign idx")?;
+                    self.emit_array_set_named(name, idx_v, val_v, i)?;
+                }
 
                 Op::Eq => self.cmp_vec(&mut stack, i, IntPredicate::EQ)?,
                 Op::Ne => self.cmp_vec(&mut stack, i, IntPredicate::NE)?,
@@ -837,6 +862,85 @@ impl<'ctx, 'a> DualBandLowerer<'ctx, 'a> {
         }
     }
 
+    /// Path D: ArrSetNamed / ArrayIndexAssign helper. Looks up the
+    /// named array slot, loads the i64-pointer-bit-pattern, inttoptrs
+    /// to a real LLVM pointer, GEPs to slot `idx + 1` (skipping the
+    /// length prefix), and stores the value's α lane.
+    ///
+    /// β is discarded on writes — the value's β was the harmonic
+    /// shadow of the value at the call site; once written into the
+    /// array, the slot only holds α (the array's storage is
+    /// scalar i64). When the value is later READ back via ArrayIndex,
+    /// it gets a fresh splatted (α, α) pair (matched bands).
+    ///
+    /// This is a deliberate semantic choice for the MVP: arrays are
+    /// classical-only storage. β-tracking through arrays would need
+    /// either parallel β arrays or a wider element type. Leaves
+    /// the door open for a future "harmonic array" type.
+    fn emit_array_set_named(
+        &mut self,
+        name: &str,
+        idx_v: VectorValue<'ctx>,
+        val_v: VectorValue<'ctx>,
+        op_idx: usize,
+    ) -> Result<(), CodegenError> {
+        let i64_type = self.ctx.i64_type();
+        // Look up the slot holding the array's pointer-bit-pattern.
+        let slot = self.get_or_create_slot(name)?;
+        // Load the <2 x i64> from the slot, extract α (pointer).
+        let arr_v_loaded = self
+            .builder
+            .build_load(self.v2i64, slot, &format!("{}_arr_load", name))
+            .map_err(|e| format!("ArrSetNamed slot load at op{}: {}", op_idx, e))?;
+        let arr_vv = match arr_v_loaded {
+            BasicValueEnum::VectorValue(vv) => vv,
+            _ => return Err(format!("ArrSetNamed slot not vector at op{}", op_idx)),
+        };
+        let arr_alpha = self
+            .builder
+            .build_extract_element(arr_vv, i64_type.const_int(0, false), "asn_aptr")
+            .map_err(|e| format!("ArrSetNamed extract α at op{}: {}", op_idx, e))?;
+        let idx_alpha = self
+            .builder
+            .build_extract_element(idx_v, i64_type.const_int(0, false), "asn_aix")
+            .map_err(|e| format!("ArrSetNamed extract idx α at op{}: {}", op_idx, e))?;
+        let val_alpha = self
+            .builder
+            .build_extract_element(val_v, i64_type.const_int(0, false), "asn_aval")
+            .map_err(|e| format!("ArrSetNamed extract val α at op{}: {}", op_idx, e))?;
+        let arr_iv = match arr_alpha {
+            BasicValueEnum::IntValue(iv) => iv,
+            _ => return Err(format!("ArrSetNamed ptr not int at op{}", op_idx)),
+        };
+        let idx_iv = match idx_alpha {
+            BasicValueEnum::IntValue(iv) => iv,
+            _ => return Err(format!("ArrSetNamed idx not int at op{}", op_idx)),
+        };
+        let val_iv = match val_alpha {
+            BasicValueEnum::IntValue(iv) => iv,
+            _ => return Err(format!("ArrSetNamed val not int at op{}", op_idx)),
+        };
+        let ptr_ty = self.ctx.ptr_type(inkwell::AddressSpace::default());
+        let ptr = self
+            .builder
+            .build_int_to_ptr(arr_iv, ptr_ty, "asn_ptr")
+            .map_err(|e| format!("ArrSetNamed inttoptr at op{}: {}", op_idx, e))?;
+        let one = i64_type.const_int(1, false);
+        let slot_idx = self
+            .builder
+            .build_int_add(idx_iv, one, "asn_slot")
+            .map_err(|e| format!("ArrSetNamed slot calc at op{}: {}", op_idx, e))?;
+        let elem_gep = unsafe {
+            self.builder
+                .build_in_bounds_gep(i64_type, ptr, &[slot_idx], "asn_gep")
+                .map_err(|e| format!("ArrSetNamed gep at op{}: {}", op_idx, e))?
+        };
+        self.builder
+            .build_store(elem_gep, val_iv)
+            .map_err(|e| format!("ArrSetNamed store at op{}: {}", op_idx, e))?;
+        Ok(())
+    }
+
     /// Path A.4: ArrayIndex — extract α (pointer) and the user-given
     /// scalar index, GEP to slot `idx + 1` (skipping the length
     /// prefix), load the element. Returns the element as a scalar i64.
diff --git a/omnimcode-codegen/tests/jit_arrays.rs b/omnimcode-codegen/tests/jit_arrays.rs
@@ -89,6 +89,64 @@ fn jit_array_sum_in_loop() {
     assert_eq!(f.call(&[0]).expect("call"), 55); // 1+2+...+10
 }
 
+#[test]
+fn jit_array_write_with_arr_set() {
+    // Path D: arr_set in a loop. Build an array of zeros, then fill
+    // with squares. Verify a known slot.
+    let source = r#"
+        fn build_squares(unused) {
+            h arr = [0, 0, 0, 0, 0];
+            h k = 0;
+            while k < 5 {
+                arr_set(arr, k, k * k);
+                k = k + 1;
+            }
+            return arr_get(arr, 3);
+        }
+    "#;
+    let mut parser = Parser::new(source);
+    let statements = parser.parse().expect("parse");
+    let module = omnimcode_core::compiler::compile_program(&statements).expect("compile");
+    let ctx = Context::create();
+    let jit = JitContext::new(&ctx).expect("jit");
+    let jitted = jit.jit_module(&module).expect("jit_module");
+    let f = jitted.get("build_squares").expect("build_squares JIT'd");
+    assert_eq!(f.call(&[0]).expect("call"), 9); // 3*3
+}
+
+#[test]
+fn jit_array_write_then_sum() {
+    // Build, write into, read back — sum the squares of 0..9.
+    let source = r#"
+        fn sum_of_squares(n) {
+            h arr = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+            h k = 0;
+            while k < n {
+                arr_set(arr, k, k * k);
+                k = k + 1;
+            }
+            h sum = 0;
+            h j = 0;
+            while j < n {
+                sum = sum + arr_get(arr, j);
+                j = j + 1;
+            }
+            return sum;
+        }
+    "#;
+    let mut parser = Parser::new(source);
+    let statements = parser.parse().expect("parse");
+    let module = omnimcode_core::compiler::compile_program(&statements).expect("compile");
+    let ctx = Context::create();
+    let jit = JitContext::new(&ctx).expect("jit");
+    let jitted = jit.jit_module(&module).expect("jit_module");
+    let f = jitted.get("sum_of_squares").expect("sum_of_squares JIT'd");
+    // 0² + 1² + 2² + … + 9² = 285
+    assert_eq!(f.call(&[10]).expect("call"), 285);
+    // 0² + 1² + 2² + 3² + 4² = 30
+    assert_eq!(f.call(&[5]).expect("call"), 30);
+}
+
 #[test]
 fn jit_array_via_dispatch_hook() {
     // End-to-end through Interpreter dispatch (matches CLI's
diff --git a/omnimcode-codegen/tests/jit_floats.rs b/omnimcode-codegen/tests/jit_floats.rs
@@ -77,6 +77,52 @@ fn float_arithmetic_via_to_float() {
     assert_eq!(f.call(&[100]).expect("call"), 10_000);
 }
 
+#[test]
+fn cross_fn_float_passing() {
+    // Path D verification: floats can flow across fn boundaries
+    // because they're encoded as i64-bit-pattern on the operand
+    // stack. Caller's Op::Call passes scalar i64; callee's
+    // bind_params_into_locals stores i64 into the slot; LoadVar
+    // returns i64; AddFloat bitcasts at use. No special boundary
+    // logic needed — the i64 encoding is the universal calling
+    // convention.
+    let source = r#"
+        fn double_it(x) {
+            return x + x;
+        }
+        fn caller(n) {
+            h xf = to_float(n);
+            h doubled = double_it(xf);
+            return to_int(doubled);
+        }
+    "#;
+    let mut parser = Parser::new(source);
+    let statements = parser.parse().expect("parse");
+    let module = omnimcode_core::compiler::compile_program(&statements).expect("compile");
+    let ctx = Context::create();
+    let jit = JitContext::new(&ctx).expect("jit");
+    let jitted = jit.jit_module(&module).expect("jit_module");
+    let f = jitted.get("caller").expect("caller JIT'd");
+    // n=21: xf = 21.0, double_it(21.0) = 42.0, to_int = 42
+    // BUT: double_it sees the i64 bit pattern of 21.0, adds it to
+    // itself as integer (Op::Add not AddFloat), producing garbage.
+    // This test documents the LIMITATION: cross-fn float passing
+    // works only when both sides agree on the type AT THE BYTECODE
+    // LEVEL. double_it has no type info on x, so it emits Op::Add
+    // (int add of bit patterns) → wrong answer.
+    //
+    // The correct cross-fn-float pattern requires explicit float-
+    // typed ops on both sides. With the OMC compiler emitting plain
+    // Op::Add for untyped inputs, the only way to guarantee correct
+    // cross-fn float math today is to pass via ints and convert at
+    // each fn boundary. Documented for honesty.
+    let r = f.call(&[21]).expect("call");
+    // The exact value depends on the bit-pattern arithmetic; what
+    // matters for this test is that the call doesn't crash and
+    // produces some deterministic answer.
+    let _ = r;
+}
+
 #[test]
 fn float_loop_accumulator() {
     // Float Add/Sub/Mul in a loop. Computes
