Section 03: Value Passing Optimization

Status: Not Started OPTIONAL — Profile-gated. Like Section 02, this optimizes the tree-walker which the VM replaces. Work this ONLY if profiling justifies it.

Goal: Eliminate avoidable Value::clone() work on the function call hot path. Current hot-path clones are a mix of cheap refcount bumps and a smaller number of real structure clones. Target: remove the expensive cases proven by profiling, without destabilizing semantics that the bytecode VM will replace anyway.

Context: The bind_parameters_with_defaults() function in compiler/ori_eval/src/exec/call/mod.rs:40-58 clones every argument via args[i].clone(). But the cost model is mixed:

Heap-backed Value variants already use Arc via Heap<T>, so many clones are shallow refcount bumps rather than deep copies
FunctionValue captures are already shared via Arc<FxHashMap<_, _>>
The remaining potentially expensive clones are inline FunctionValue/MemoizedFunctionValue payload clones and repeated rebinding of captured values into fresh environments

Reference implementations:

CPython: Py_INCREF per parameter — refcount increment only, no deep clone
Lua: Arguments stay in caller’s stack frame; callee reads via offset — zero copy

Depends on: Section 01 (benchmarks). Independent of Section 02 (can be done in either order).

03.1 Parameter Binding Without Clone

File(s): compiler/ori_eval/src/exec/call/mod.rs

Current code (exec/call/mod.rs:40-58):

pub fn bind_parameters_with_defaults(
    interpreter: &mut crate::Interpreter<'_>,
    func: &FunctionValue,
    args: &[Value],
) -> Result<(), ControlAction> {
    let can_defaults = func.can_defaults();
    for (i, param) in func.params.iter().enumerate() {
        let value = if i < args.len() {
            args[i].clone()  // <-- Clone per parameter
        } else if let Some(Some(can_id)) = can_defaults.get(i) {
            interpreter.eval_can(*can_id)?
        } else {
            return Err(EvalError::new(...).into());
        };
        interpreter.env.define(*param, value, Mutability::Immutable);
    }
    Ok(())
}

Fix: Only move values instead of cloning when measurement shows clone work is still material after Section 02. Otherwise, preserve API stability and spend the effort on the bytecode path.

03.2 Self-Binding and Capture Optimization

File(s): compiler/ori_eval/src/interpreter/function_call.rs, compiler/ori_eval/src/exec/call/mod.rs

Current self-binding (function_call.rs:51-52):

call_interpreter
    .env
    .define(self_name, func.clone(), Mutability::Immutable);

func.clone() on a Value::Function(FunctionValue) clones the FunctionValue struct which contains: params: Vec<Name> (clone = new Vec alloc), can_defaults: Vec<Option<CanId>> (clone = new Vec alloc), capabilities: Vec<Name> (clone = new Vec alloc), plus three cheap Arc bumps (captures: Arc<FxHashMap>, arena: SharedArena, canon: Option<SharedCanonResult>). This is a real cost for the Vec clones, but it must be measured before the representation is widened.

Fix: Store a reference or lightweight handle instead of cloning the entire FunctionValue.

03.R Third Party Review Findings

None.

03.N Completion Checklist

Exit Criteria: Combined with Section 02, per-call cost ≤5µs (down from 63µs). Ackermann A(3,7) completes in <10s. Zero unnecessary clones on the hot path (verified by audit of function_call.rs and exec/call/mod.rs).