Method handle_container

compiler/src/modules/vm/handlers/data.rs:47–103

Indexed access/store, unpacking, and `{value!s:spec}` formatting. `GetItem`/`StoreItem`/`DelItem` are dispatched directly from the hot loop; the arms below cover legacy callers that may route through here. */

(&mut self, op: OpCode, operand: u16, chunk: &SSAChunk, slots: &mut [Val])

    /* Indexed access/store, unpacking, and `{value!s:spec}` formatting. `GetItem`/`StoreItem`/`DelItem` are dispatched directly from the hot loop; the arms below cover legacy callers that may route through here. */
    pub(crate) fn handle_container(&mut self, op: OpCode, operand: u16, chunk: &SSAChunk, slots: &mut [Val]) -> Result<(), VmErr> {
        match op {
            OpCode::StoreItem => {
                self.mark_impure();
                self.store_item(chunk, slots)?;
            }
            OpCode::DelItem => {
                self.mark_impure();
                self.del_item(chunk, slots)?;
            }
            OpCode::UnpackSequence => self.exec_unpack_seq(operand as usize)?,
            OpCode::UnpackEx => self.unpack_ex(operand)?,
            OpCode::FormatValue => {
                /* Operand layout: bit 0 has_spec, bits 1..=2 conversion (0 none, 1 !r, 2 !s, 3 !a). See parser/literals.rs. */
                let has_spec = (operand & 1) != 0;
                let conv = (operand >> 1) & 0b11;
                let spec_val = if has_spec { Some(self.pop()?) } else { None };
                let v = self.pop()?;

                // Conversion flags consult the dunder-aware helpers so `f"{x!s}"` honours `__str__`.
                // Charge each result's length; a big Str is one heap object the object quota misses.
                let converted = match conv {
                    1 => { let s = self.repr_op(v, chunk, slots)?; self.charge_steps(s.len())?; self.heap.alloc(HeapObj::Str(s))? }
                    2 => { let s = self.display_op(v, chunk, slots)?; self.charge_steps(s.len())?; self.heap.alloc(HeapObj::Str(s))? }
                    3 => {
                        let raw = super::format::display_inline(v, &self.heap);
                        self.charge_steps(raw.len())?;
                        self.heap.alloc(HeapObj::Str(raw.escape_default().collect::<String>()))?
                    }
                    _ => v,
                };

                let result = match spec_val {
                    Some(sv) => {
                        // `try_get`: a non-heap spec value is a TypeError, not a bad-index heap access.
                        let spec = match self.heap.try_get(sv) {
                            Some(HeapObj::Str(s)) => s.clone(),
                            _ => return Err(cold_type("format spec must be a string")),
                        };
                        // Instance `__format__(spec)` runs through `format_op`; built-ins fall through to the spec engine.
                        self.format_op(converted, &spec, chunk, slots)?
                    }
                    None => {
                        if conv != 0 && let HeapObj::Str(s) = self.heap.get(converted) {
                            s.clone()
                        } else {
                            self.display_op(converted, chunk, slots)?
                        }
                    }
                };
                let val = self.heap.alloc(HeapObj::Str(result))?;
                self.push(val);
            }
            _ => return Err(cold_runtime("non-container opcode in handle_container")),
        }
        Ok(())
    }