superacli 1.1.4 → 1.1.6

package/ref-monty/crates/monty/src/bytecode/vm/compare.rs

@@ -0,0 +1,147 @@
+//! Comparison operation helpers for the VM.
+
+use super::VM;
+use crate::{
+    defer_drop,
+    exception_private::{ExcType, RunError},
+    resource::ResourceTracker,
+    types::{LongInt, PyTrait},
+    value::Value,
+};
+
+impl<T: ResourceTracker> VM<'_, '_, T> {
+    /// Equality comparison.
+    pub(super) fn compare_eq(&mut self) -> Result<(), RunError> {
+        let this = self;
+
+        let rhs = this.pop();
+        defer_drop!(rhs, this);
+        let lhs = this.pop();
+        defer_drop!(lhs, this);
+
+        let result = lhs.py_eq(rhs, this)?;
+        this.push(Value::Bool(result));
+        Ok(())
+    }
+
+    /// Inequality comparison.
+    pub(super) fn compare_ne(&mut self) -> Result<(), RunError> {
+        let this = self;
+
+        let rhs = this.pop();
+        defer_drop!(rhs, this);
+        let lhs = this.pop();
+        defer_drop!(lhs, this);
+
+        let result = !lhs.py_eq(rhs, this)?;
+        this.push(Value::Bool(result));
+        Ok(())
+    }
+
+    /// Ordering comparison with a predicate.
+    pub(super) fn compare_ord<F>(&mut self, check: F) -> Result<(), RunError>
+    where
+        F: FnOnce(std::cmp::Ordering) -> bool,
+    {
+        let this = self;
+
+        let rhs = this.pop();
+        defer_drop!(rhs, this);
+        let lhs = this.pop();
+        defer_drop!(lhs, this);
+
+        let result = lhs.py_cmp(rhs, this)?.is_some_and(check);
+        this.push(Value::Bool(result));
+        Ok(())
+    }
+
+    /// Identity comparison (is/is not).
+    ///
+    /// Compares identity using `Value::is()` which compares IDs.
+    ///
+    /// Identity is determined by `Value::id()` which uses:
+    /// - Fixed IDs for singletons (None, True, False, Ellipsis)
+    /// - Interned string/bytes index for InternString/InternBytes
+    /// - HeapId for heap-allocated values (Ref)
+    /// - Value-based hashing for immediate types (Int, Float, Function, etc.)
+    pub(super) fn compare_is(&mut self, negate: bool) {
+        let this = self;
+
+        let rhs = this.pop();
+        defer_drop!(rhs, this);
+        let lhs = this.pop();
+        defer_drop!(lhs, this);
+
+        let result = lhs.is(rhs);
+        this.push(Value::Bool(if negate { !result } else { result }));
+    }
+
+    /// Membership test (in/not in).
+    pub(super) fn compare_in(&mut self, negate: bool) -> Result<(), RunError> {
+        let this = self;
+
+        let container = this.pop(); // container (rhs)
+        defer_drop!(container, this);
+        let item = this.pop(); // item to find (lhs)
+        defer_drop!(item, this);
+
+        let contained = container.py_contains(item, this)?;
+        this.push(Value::Bool(if negate { !contained } else { contained }));
+        Ok(())
+    }
+
+    /// Modulo equality comparison: a % b == k
+    ///
+    /// This is an optimization for patterns like `x % 3 == 0`. The constant k
+    /// is provided by the caller (fetched from the constant pool using the
+    /// cached code reference in the run loop).
+    ///
+    /// Uses a fast path for Int/Float types via `py_mod_eq`, and falls back to
+    /// computing `py_mod` then comparing with `py_eq` for other types (e.g., LongInt).
+    pub(super) fn compare_mod_eq(&mut self, k: &Value) -> Result<(), RunError> {
+        let this = self;
+
+        let rhs = this.pop(); // divisor (b)
+        defer_drop!(rhs, this);
+        let lhs = this.pop(); // dividend (a)
+        defer_drop!(lhs, this);
+
+        // Try fast path for Int/Float types
+        let mod_result = match k {
+            Value::Int(k_val) => lhs.py_mod_eq(rhs, *k_val),
+            _ => None,
+        };
+
+        if let Some(is_equal) = mod_result {
+            // Fast path succeeded
+            this.push(Value::Bool(is_equal));
+            Ok(())
+        } else {
+            // Fallback: compute py_mod then compare with py_eq
+            // This handles LongInt and other Ref types
+            let mod_value = lhs.py_mod(rhs, this);
+
+            match mod_value {
+                Ok(Some(v)) => {
+                    defer_drop!(v, this);
+
+                    // Handle InternLongInt by converting to heap LongInt for comparison
+                    let k_value = if let Value::InternLongInt(id) = k {
+                        let bi = this.interns.get_long_int(*id).clone();
+                        LongInt::new(bi).into_value(this.heap)?
+                    } else {
+                        // k is from the constant pool and is always an immediate value
+                        k.clone_immediate()
+                    };
+                    defer_drop!(k_value, this);
+
+                    let is_equal = v.py_eq(k_value, this)?;
+                    this.push(Value::Bool(is_equal));
+                    Ok(())
+                }
+                Ok(None) => Err(ExcType::type_error("unsupported operand type(s) for %")),
+                Err(e) => Err(e),
+            }
+        }
+    }
+}

package/ref-monty/crates/monty/src/bytecode/vm/exceptions.rs

@@ -0,0 +1,297 @@
+//! Exception handling helpers for the VM.
+
+use super::VM;
+use crate::{
+    builtins::Builtins,
+    defer_drop,
+    exception_private::{ExcType, ExceptionRaise, RawStackFrame, RunError, SimpleException},
+    heap::{HeapData, HeapGuard},
+    intern::{StaticStrings, StringId},
+    resource::ResourceTracker,
+    types::{PyTrait, Type},
+    value::Value,
+};
+
+impl<T: ResourceTracker> VM<'_, '_, T> {
+    /// Returns the current frame's name for traceback generation.
+    ///
+    /// Returns the function name for user-defined functions, or `<module>` for
+    /// module-level code.
+    fn current_frame_name(&self) -> StringId {
+        let frame = self.current_frame();
+        match frame.function_id {
+            Some(func_id) => self.interns.get_function(func_id).name.name_id,
+            None => StaticStrings::Module.into(),
+        }
+    }
+
+    /// Creates a `RawStackFrame` for the current execution point.
+    ///
+    /// Used when raising exceptions to capture traceback information.
+    fn make_stack_frame(&self) -> RawStackFrame {
+        RawStackFrame::new(self.current_position(), self.current_frame_name(), None)
+    }
+
+    /// Attaches initial frame information to an error if it doesn't have any.
+    ///
+    /// Only sets the innermost frame if the exception doesn't already have one.
+    /// Caller frames are added separately during exception propagation.
+    ///
+    /// Uses the `hide_caret` flag from `ExceptionRaise` to determine whether to show
+    /// the caret marker in the traceback. This flag is set by error creators that know
+    /// whether CPython would show a caret for this specific error type.
+    fn attach_frame_to_error(&self, error: RunError) -> RunError {
+        match error {
+            RunError::Exc(mut exc) => {
+                if exc.frame.is_none() {
+                    let mut frame = self.make_stack_frame();
+                    // Use the hide_caret flag from the error (set by error creators)
+                    frame.hide_caret = exc.hide_caret;
+                    exc.frame = Some(frame);
+                }
+                RunError::Exc(exc)
+            }
+            RunError::UncatchableExc(mut exc) => {
+                if exc.frame.is_none() {
+                    let mut frame = self.make_stack_frame();
+                    frame.hide_caret = exc.hide_caret;
+                    exc.frame = Some(frame);
+                }
+                RunError::UncatchableExc(exc)
+            }
+            RunError::Internal(_) => error,
+        }
+    }
+
+    /// Creates a RunError from a Value that should be an exception.
+    ///
+    /// Takes ownership of the exception value and drops it properly.
+    /// The `is_raise` flag indicates if this is from a `raise` statement (hide caret).
+    pub(super) fn make_exception(&mut self, exc_value: Value, is_raise: bool) -> RunError {
+        let this = self;
+        defer_drop!(exc_value, this);
+
+        let simple_exc = match exc_value {
+            // Exception instance on heap
+            Value::Ref(heap_id) => {
+                if let HeapData::Exception(exc) = this.heap.get(*heap_id) {
+                    // Clone the exception (guard handles cleanup at scope exit)
+                    exc.clone()
+                } else {
+                    // Not an exception type
+                    SimpleException::new_msg(ExcType::TypeError, "exceptions must derive from BaseException")
+                }
+            }
+            // Exception type (e.g., `raise ValueError` instead of `raise ValueError()`)
+            // Instantiate with no message
+            Value::Builtin(Builtins::ExcType(exc_type)) => SimpleException::new_none(*exc_type),
+            // Invalid exception value
+            _ => SimpleException::new_msg(ExcType::TypeError, "exceptions must derive from BaseException"),
+        };
+
+        // Create frame with appropriate hide_caret setting
+        let frame = if is_raise {
+            RawStackFrame::from_raise(this.current_position(), this.current_frame_name())
+        } else {
+            this.make_stack_frame()
+        };
+
+        RunError::Exc(ExceptionRaise {
+            exc: simple_exc,
+            frame: Some(frame),
+            hide_caret: false,
+        })
+    }
+
+    /// Handles an exception by searching for a handler in the exception table.
+    ///
+    /// Returns:
+    /// - `Some(VMResult)` if the exception was not caught (should return from run loop)
+    /// - `None` if the exception was caught (continue execution)
+    ///
+    /// When an exception is caught:
+    /// 1. Unwinds the stack to the handler's expected depth
+    /// 2. Pushes the exception value onto the stack
+    /// 3. Sets `current_exception` for bare `raise`
+    /// 4. Jumps to the handler code
+    pub(super) fn handle_exception(&mut self, mut error: RunError) -> Option<RunError> {
+        // Ensure exception has initial frame info
+        error = self.attach_frame_to_error(error);
+
+        // For uncatchable exceptions (ResourceError like RecursionError),
+        // we still need to unwind the stack to collect all frames for the traceback
+        if matches!(error, RunError::UncatchableExc(_) | RunError::Internal(_)) {
+            return Some(self.unwind_for_traceback(error));
+        }
+
+        // Only catchable exceptions can be handled
+        let exc_info = match &error {
+            RunError::Exc(exc) => exc.clone(),
+            RunError::UncatchableExc(_) | RunError::Internal(_) => unreachable!(),
+        };
+
+        // Create exception value to push on stack
+        let exc_value = self.create_exception_value(&exc_info);
+        let exc_value = match exc_value {
+            Ok(v) => v,
+            Err(e) => return Some(e),
+        };
+
+        // Use HeapGuard because exc_value is conditionally consumed (pushed onto
+        // exception_stack when handler found) or dropped (when no handler found)
+        let mut exc_guard = HeapGuard::new(exc_value, self);
+
+        // Search for handler in current and outer frames
+        loop {
+            let (exc_value, this) = exc_guard.as_parts();
+            let frame = this.current_frame();
+            let ip = u32::try_from(this.instruction_ip).expect("instruction IP exceeds u32");
+
+            // Search exception table for a handler covering this IP
+            if let Some(entry) = frame.code.find_exception_handler(ip) {
+                // Found a handler! Unwind stack and jump to it.
+                let handler_offset = usize::try_from(entry.handler()).expect("handler offset exceeds usize");
+                let target_stack_depth = frame.stack_base + frame.locals_count as usize + entry.stack_depth() as usize;
+
+                // Unwind stack to target depth (drop excess values)
+                while this.stack.len() > target_stack_depth {
+                    let value = this.stack.pop().unwrap();
+                    value.drop_with_heap(this);
+                }
+
+                // Push exception value onto stack (handler expects it)
+                let exc_for_stack = exc_value.clone_with_heap(this.heap);
+                this.push(exc_for_stack);
+
+                // Reclaim exc_value from guard - it's being pushed onto exception_stack
+                let (exc_value, this) = exc_guard.into_parts();
+
+                // Push exception onto the exception_stack for bare raise
+                // This allows nested except handlers to restore outer exception context
+                this.exception_stack.push(exc_value);
+
+                // Jump to handler
+                this.current_frame_mut().ip = handler_offset;
+
+                return None; // Continue execution at handler
+            }
+
+            // No handler in this frame - pop frame and try outer
+            if this.frames.len() <= 1 {
+                // No more frames - exception is unhandled
+                let is_spawned = this.is_spawned_task();
+
+                // Drop exc_value before potentially switching tasks
+                drop(exc_guard);
+
+                // For spawned tasks, fail the task instead of propagating
+                if is_spawned {
+                    match self.handle_task_failure(error) {
+                        Ok(()) => {
+                            // Switched to next task - continue execution
+                            return None;
+                        }
+                        Err(waiter_error) => {
+                            // Switched to waiter - handle error in waiter's context
+                            return self.handle_exception(waiter_error);
+                        }
+                    }
+                }
+
+                return Some(error);
+            }
+
+            // Get the call site position before popping frame
+            // This is where the caller invoked the function that's failing
+            let call_position = this.current_frame().call_position;
+
+            // Pop this frame
+            if this.pop_frame() {
+                // The frame indicated evaluation should stop - e.g. inside `evaluate_function` - return the error
+                // now to stop unwinding.
+                return Some(error);
+            }
+
+            // Add caller frame info to traceback (if we have call position)
+            if let Some(pos) = call_position {
+                let frame_name = this.current_frame_name();
+                match &mut error {
+                    RunError::Exc(exc) => exc.add_caller_frame(pos, frame_name),
+                    RunError::UncatchableExc(exc) => exc.add_caller_frame(pos, frame_name),
+                    RunError::Internal(_) => {}
+                }
+            }
+        }
+    }
+
+    /// Unwinds the call stack to collect all frames for a traceback.
+    ///
+    /// Used for uncatchable exceptions (like RecursionError) that can't be handled
+    /// but still need a complete traceback showing all active call frames.
+    fn unwind_for_traceback(&mut self, mut error: RunError) -> RunError {
+        // Pop frames and add caller frame info to the traceback
+        while self.frames.len() > 1 {
+            // Get the call site position before popping frame
+            let call_position = self.current_frame().call_position;
+
+            // Pop this frame (cleans up namespace, etc.)
+            self.pop_frame();
+
+            // Add caller frame info to traceback
+            if let Some(pos) = call_position {
+                let frame_name = self.current_frame_name();
+                match &mut error {
+                    RunError::Exc(exc) => exc.add_caller_frame(pos, frame_name),
+                    RunError::UncatchableExc(exc) => exc.add_caller_frame(pos, frame_name),
+                    RunError::Internal(_) => {}
+                }
+            }
+        }
+        error
+    }
+
+    /// Creates an exception Value from exception info.
+    ///
+    /// Allocates an Exception on the heap and returns a Value::Ref to it.
+    fn create_exception_value(&mut self, exc: &ExceptionRaise) -> Result<Value, RunError> {
+        let exception = exc.exc.clone();
+        let heap_id = self.heap.allocate(HeapData::Exception(exception))?;
+        Ok(Value::Ref(heap_id))
+    }
+
+    /// Checks if an exception matches an exception type for except clause matching.
+    ///
+    /// Validates that `exc_type` is a valid exception type (ExcType or tuple of ExcTypes).
+    /// Returns `Ok(true)` if exception matches, `Ok(false)` if not, or `Err` if exc_type is invalid.
+    pub(super) fn check_exc_match(&self, exception: &Value, exc_type: &Value) -> Result<bool, RunError> {
+        let exc_type_enum = exception.py_type(self.heap);
+        self.check_exc_match_inner(exc_type_enum, exc_type)
+    }
+
+    /// Inner recursive helper for check_exc_match that handles tuples.
+    fn check_exc_match_inner(&self, exc_type_enum: Type, exc_type: &Value) -> Result<bool, RunError> {
+        match exc_type {
+            // Valid exception type
+            Value::Builtin(Builtins::ExcType(handler_type)) => {
+                // Check if exception is an instance of handler_type
+                Ok(matches!(exc_type_enum, Type::Exception(et) if et.is_subclass_of(*handler_type)))
+            }
+            // Tuple of exception types
+            Value::Ref(id) => {
+                if let HeapData::Tuple(tuple) = self.heap.get(*id) {
+                    for v in tuple.as_slice() {
+                        if self.check_exc_match_inner(exc_type_enum, v)? {
+                            return Ok(true);
+                        }
+                    }
+                    Ok(false)
+                } else {
+                    // Not a tuple - invalid exception type
+                    Err(ExcType::except_invalid_type_error())
+                }
+            }
+            // Any other type is invalid for except clause
+            _ => Err(ExcType::except_invalid_type_error()),
+        }
+    }
+}

package/ref-monty/crates/monty/src/bytecode/vm/format.rs

@@ -0,0 +1,132 @@
+//! F-string and value formatting helpers for the VM.
+
+use super::VM;
+use crate::{
+    defer_drop,
+    exception_private::{ExcType, RunError, SimpleException},
+    fstring::{ParsedFormatSpec, ascii_escape, decode_format_spec, format_string, format_with_spec},
+    resource::{ResourceTracker, check_repeat_size},
+    types::{PyTrait, str::allocate_string},
+    value::Value,
+};
+
+impl<T: ResourceTracker> VM<'_, '_, T> {
+    /// Builds an f-string by concatenating n string parts from the stack.
+    pub(super) fn build_fstring(&mut self, count: usize) -> Result<(), RunError> {
+        let parts = self.pop_n(count);
+        let mut result = String::new();
+
+        for part in parts {
+            // Each part should be a string (interned or heap-allocated)
+            let part_str = part.py_str(self);
+            result.push_str(&part_str);
+            part.drop_with_heap(self);
+        }
+
+        let value = allocate_string(result, self.heap)?;
+        self.push(value);
+        Ok(())
+    }
+
+    /// Formats a value for f-string interpolation.
+    ///
+    /// Flags encoding:
+    /// - bits 0-1: conversion (0=none, 1=str, 2=repr, 3=ascii)
+    /// - bit 2: has format spec on stack
+    ///
+    /// Python f-string formatting order:
+    /// 1. Apply format spec to original value (type-specific formatting)
+    /// 2. Apply conversion flag to the result
+    ///
+    /// However, conversion flags like !s, !r, !a are applied BEFORE formatting
+    /// if the value would be repr'd. The key insight is:
+    /// - No conversion: format the original value type
+    /// - !s conversion: convert to str first, then format as string
+    /// - !r conversion: convert to repr first, then format as string
+    /// - !a conversion: convert to ascii repr first, then format as string
+    pub(super) fn format_value(&mut self, flags: u8) -> Result<(), RunError> {
+        let this = self;
+        let conversion = flags & 0x03;
+        let has_format_spec = (flags & 0x04) != 0;
+
+        // Pop format spec if present (pushed before value, so popped after)
+        let format_spec = if has_format_spec { Some(this.pop()) } else { None };
+
+        let value = this.pop();
+        defer_drop!(value, this);
+
+        // Format with spec applied to original value type, or convert and format as string
+        let formatted = if let Some(spec_value) = format_spec {
+            defer_drop!(spec_value, this);
+
+            let spec = this.get_format_spec(spec_value, value)?;
+
+            // Pre-check: reject format specs with huge width before pad_string
+            // allocates an untracked Rust String.
+            check_repeat_size(spec.width, spec.fill.len_utf8(), this.heap.tracker())?;
+
+            match conversion {
+                // No conversion - format original value
+                0 => format_with_spec(value, &spec, this)?,
+                // !s - convert to str, format as string
+                1 => {
+                    let s = value.py_str(this);
+                    format_string(&s, &spec)?
+                }
+                // !r - convert to repr, format as string
+                2 => {
+                    let s = value.py_repr(this);
+                    format_string(&s, &spec)?
+                }
+                // !a - convert to ascii, format as string
+                3 => {
+                    let s = ascii_escape(&value.py_repr(this));
+                    format_string(&s, &spec)?
+                }
+                _ => format_with_spec(value, &spec, this)?,
+            }
+        } else {
+            // No format spec - just convert based on conversion flag
+            match conversion {
+                0 => value.py_str(this).into_owned(),
+                1 => value.py_str(this).into_owned(),
+                2 => value.py_repr(this).into_owned(),
+                3 => ascii_escape(&value.py_repr(this)),
+                _ => value.py_str(this).into_owned(),
+            }
+        };
+
+        let result = allocate_string(formatted, this.heap)?;
+        this.push(result);
+        Ok(())
+    }
+
+    /// Gets a ParsedFormatSpec from a format spec value.
+    ///
+    /// The `value_for_error` parameter is used to include the value type in error messages.
+    /// Uses lazy type capture: only calls `py_type()` in error paths.
+    fn get_format_spec(&self, spec_value: &Value, value_for_error: &Value) -> Result<ParsedFormatSpec, RunError> {
+        match spec_value {
+            Value::Int(n) if *n < 0 => {
+                // Decode the encoded format spec; n < 0 ensures (-n - 1) >= 0
+                let encoded = u64::try_from((-*n) - 1).expect("format spec encoding validated non-negative");
+                Ok(decode_format_spec(encoded))
+            }
+            _ => {
+                // Dynamic format spec - parse the string
+                let spec_str = spec_value.py_str(self);
+                spec_str.parse::<ParsedFormatSpec>().map_err(|invalid| {
+                    // Only fetch type in error path
+                    let value_type = value_for_error.py_type(self.heap);
+                    RunError::Exc(
+                        SimpleException::new_msg(
+                            ExcType::ValueError,
+                            format!("Invalid format specifier '{invalid}' for object of type '{value_type}'"),
+                        )
+                        .into(),
+                    )
+                })
+            }
+        }
+    }
+}