Method add_vals

compiler/src/modules/vm/ops.rs:436–477

(&mut self, a: Val, b: Val)

        Err(VmErr::TypeMsg(s!("argument of type '", str self.type_name(container), "' is not iterable")))
    }
    pub fn add_vals(&mut self, a: Val, b: Val) -> Result<Val, VmErr> {
        // Inline-int fast path; overflow falls through to the i128 slow path.
        if a.is_int() && b.is_int()
            && let Some(r) = a.as_int().checked_add(b.as_int())
            && (Val::INT_MIN..=Val::INT_MAX).contains(&r) {
            return Ok(Val::int(r));
        }
        if let Some((af, bf)) = coerce_floats(a, b, &self.heap) { return Ok(Val::float(af + bf)); }
        // Wide-int slow path; int_to_val picks the narrowest storage class.
        if let (Some(ai), Some(bi)) = (as_i128(a, &self.heap), as_i128(b, &self.heap)) {
            return self.int_to_val(ai.checked_add(bi));
        }
        if a.is_heap() && b.is_heap() {
            // Charge the copy cost so growing concatenation in a loop stays bounded (avoids O(n^2)).
            let copy_cost = match (self.heap.get(a), self.heap.get(b)) {
                (HeapObj::Str(sa), HeapObj::Str(sb)) => Some(sa.len() + sb.len()),
                (HeapObj::List(va), HeapObj::List(vb)) => Some(va.borrow().len() + vb.borrow().len()),
                (HeapObj::Tuple(va), HeapObj::Tuple(vb)) => Some(va.len() + vb.len()),
                _ => None,
            };
            if let Some(n) = copy_cost { self.charge_steps(n)?; }
            match (self.heap.get(a), self.heap.get(b)) {
                (HeapObj::Str(sa), HeapObj::Str(sb)) => {
                    let sa = sa.clone();
                    let sb = sb.clone();
                    let mut r = String::with_capacity(sa.len() + sb.len());
                    r.push_str(&sa); r.push_str(&sb);
                    return self.heap.alloc(HeapObj::Str(r));
                }
                (HeapObj::List(va), HeapObj::List(vb)) => {
                    let mut lst = va.borrow().clone(); lst.extend_from_slice(&vb.borrow());
                    return self.heap.alloc(HeapObj::List(Rc::new(RefCell::new(lst))));
                }
                (HeapObj::Tuple(va), HeapObj::Tuple(vb)) => {
                    let mut tup = va.clone(); tup.extend_from_slice(vb);
                    return self.heap.alloc(HeapObj::Tuple(tup));
                }
                _ => {}
            }
        }
        Err(VmErr::TypeMsg(s!("unsupported operand type(s) for +: '", str self.type_name(a), "' and '", str self.type_name(b), "'")))
    }

    pub fn sub_vals(&mut self, a: Val, b: Val) -> Result<Val, VmErr> {
        if a.is_int() && b.is_int()