superacli 1.1.5 → 1.1.7

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

@@ -1,147 +0,0 @@
-//! 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

@@ -1,297 +0,0 @@
-//! 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

@@ -1,132 +0,0 @@
-//! 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(),
-                    )
-                })
-            }
-        }
-    }
-}