Method handle_side

compiler/src/modules/vm/handlers/data.rs:177–267

Side-effecting / impure ops: assert, del, global/nonlocal, import, type alias, raise, await. */

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

    /* Side-effecting / impure ops: assert, del, global/nonlocal, import, type alias, raise, await. */
    pub(crate) fn handle_side(&mut self, op: OpCode, operand: u16, chunk: &SSAChunk, slots: &mut [Val]) -> Result<(), VmErr> {
        match op {
            OpCode::Assert => {
                let v = self.pop()?;
                if !self.truthy_op(v, chunk, slots)? {
                    // Bare `assert` raises a catchable AssertionError with empty args.
                    let inst = self.heap.alloc(HeapObj::ExcInstance("AssertionError".into(), Vec::new()))?;
                    self.pending.exc_val = Some(inst);
                    return Err(VmErr::Raised("AssertionError".into()));
                }
            }
            OpCode::Del => {
                let slot = operand as usize;
                // Deleting an already-unbound name raises NameError, matching CPython.
                match slots.get_mut(slot) {
                    Some(s) if !s.is_undef() => *s = Val::undef(),
                    _ => {
                        let name = chunk.names.get(slot).map(|n| ssa_strip(n)).unwrap_or_default();
                        return Err(VmErr::Name(name.into()));
                    }
                }
                // At module scope, drop it from module_state too so later reads see the deletion.
                if core::ptr::eq(chunk, self.chunk) && let Some(n) = chunk.names.get(slot) {
                    self.module_state.remove(ssa_strip(n));
                }
                // Unbind the shared closure cell too, so closures over this name see the deletion.
                let cell = self.call_stack.last()
                    .and_then(|f| f.cells.iter().find(|(s, _)| *s == slot).map(|&(_, c)| c));
                if let Some(cell) = cell && cell.is_heap() && let HeapObj::List(rc) = self.heap.get(cell) {
                    rc.borrow_mut()[0] = Val::undef(); // cells are 1-element boxes
                }
            }
            OpCode::Global | OpCode::Nonlocal => self.mark_impure(),
            OpCode::Raise | OpCode::RaiseFrom => {
                self.mark_impure();
                // Bare `raise` (operand 1): re-raise the exception currently being handled.
                if op == OpCode::Raise && operand == 1 {
                    let Some(exc) = self.handling_exc else {
                        return Err(VmErr::Runtime("No active exception to re-raise"));
                    };
                    let name = self.exc_type_name(exc);
                    self.pending.exc_val = Some(exc);
                    return Err(VmErr::Raised(name));
                }
                // RaiseFrom emits both `expr` then `from expr`, the topmost value is the cause, but the exception to raise is the LHS.
                if op == OpCode::RaiseFrom { let _cause = self.pop()?; }
                let exc = self.pop()?;
                // Stash the Val for `except as e` binding; non-Exc values use `display()`.
                self.pending.exc_val = None;
                // Extract owned (class name, first arg) so display() can run after the heap borrow ends.
                let info: Option<(alloc::string::String, Option<Val>)> = if exc.is_heap() {
                    match self.heap.get(exc) {
                        HeapObj::ExcInstance(n, args) => {
                            self.pending.exc_val = Some(exc);
                            Some((n.clone(), args.first().copied()))
                        }
                        HeapObj::Type(n) => {
                            // Bare `raise X`: build empty ExcInstance so `e.args` is `()`.