superacli 1.1.6 → 1.1.8

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

@@ -1,63 +0,0 @@
-//! Attribute access helpers for the VM.
-
-use super::VM;
-use crate::{
-    bytecode::vm::CallResult,
-    defer_drop,
-    exception_private::{ExcType, RunError},
-    intern::StringId,
-    resource::ResourceTracker,
-    value::EitherStr,
-};
-
-impl<T: ResourceTracker> VM<'_, '_, T> {
-    /// Loads an attribute from an object and pushes it onto the stack.
-    ///
-    /// Returns an AttributeError if the attribute doesn't exist.
-    pub(super) fn load_attr(&mut self, name_id: StringId) -> Result<CallResult, RunError> {
-        let this = self;
-
-        let obj = this.pop();
-        defer_drop!(obj, this);
-
-        let attr = EitherStr::Interned(name_id);
-        obj.py_getattr(&attr, this)
-    }
-
-    /// Loads an attribute from a module for `from ... import` and pushes it onto the stack.
-    ///
-    /// Returns an ImportError (not AttributeError) if the attribute doesn't exist,
-    /// matching CPython's behavior for `from module import name`.
-    pub(super) fn load_attr_import(&mut self, name_id: StringId) -> Result<CallResult, RunError> {
-        let this = self;
-
-        let obj = this.pop();
-        defer_drop!(obj, this);
-
-        let attr = EitherStr::Interned(name_id);
-        match obj.py_getattr(&attr, this) {
-            Ok(result) => Ok(result),
-            Err(RunError::Exc(exc)) if exc.exc.exc_type() == ExcType::AttributeError => {
-                // Only compute module_name when we need it for the error message
-                let module_name = obj.module_name(this.heap, this.interns);
-                let name_str = this.interns.get_str(name_id);
-                Err(ExcType::cannot_import_name(name_str, &module_name))
-            }
-            Err(e) => Err(e),
-        }
-    }
-
-    /// Stores a value as an attribute on an object.
-    ///
-    /// Returns an AttributeError if the attribute cannot be set.
-    pub(super) fn store_attr(&mut self, name_id: StringId) -> Result<(), RunError> {
-        let this = self;
-
-        let obj = this.pop();
-        defer_drop!(obj, this);
-
-        let value = this.pop();
-        // py_set_attr takes ownership of value and drops it on error
-        obj.py_set_attr(name_id, value, this)
-    }
-}

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

@@ -1,487 +0,0 @@
-//! Binary and in-place operation helpers for the VM.
-
-use super::VM;
-use crate::{
-    defer_drop,
-    exception_private::{ExcType, RunError},
-    heap::{Heap, HeapData, HeapGuard},
-    resource::ResourceTracker,
-    types::{PyTrait, Set, dict_view::collect_iterable_to_set, set::SetBinaryOp},
-    value::BitwiseOp,
-};
-
-impl<T: ResourceTracker> VM<'_, '_, T> {
-    /// Binary addition with proper refcount handling.
-    ///
-    /// Uses lazy type capture: only calls `py_type()` in error paths to avoid
-    /// overhead on the success path (99%+ of operations).
-    pub(super) fn binary_add(&mut self) -> Result<(), RunError> {
-        let this = self;
-
-        let rhs = this.pop();
-        defer_drop!(rhs, this);
-        let lhs = this.pop();
-        defer_drop!(lhs, this);
-
-        match lhs.py_add(rhs, this) {
-            Ok(Some(v)) => {
-                this.push(v);
-                Ok(())
-            }
-            Ok(None) => {
-                let lhs_type = lhs.py_type(this.heap);
-                let rhs_type = rhs.py_type(this.heap);
-                Err(ExcType::binary_type_error("+", lhs_type, rhs_type))
-            }
-            Err(e) => Err(e.into()),
-        }
-    }
-
-    /// Binary subtraction with proper refcount handling.
-    ///
-    /// Handles both numeric subtraction and set difference (`-` operator).
-    /// For sets/frozensets, delegates to [`binary_set_op`] which needs `interns`
-    /// for element hashing and equality. Uses lazy type capture: only calls
-    /// `py_type()` in error paths.
-    pub(super) fn binary_sub(&mut self) -> Result<(), RunError> {
-        let this = self;
-
-        let rhs = this.pop();
-        defer_drop!(rhs, this);
-        let lhs = this.pop();
-        defer_drop!(lhs, this);
-
-        if let Some(result) = this.binary_dict_view_op(lhs, rhs, DictViewBinaryOp::Sub)? {
-            this.push(result);
-            return Ok(());
-        }
-
-        if let Some(result) = this.binary_set_op(lhs, rhs, SetBinaryOp::Sub)? {
-            this.push(result);
-            return Ok(());
-        }
-
-        match lhs.py_sub(rhs, this) {
-            Ok(Some(v)) => {
-                this.push(v);
-                Ok(())
-            }
-            Ok(None) => {
-                let lhs_type = lhs.py_type(this.heap);
-                let rhs_type = rhs.py_type(this.heap);
-                Err(ExcType::binary_type_error("-", lhs_type, rhs_type))
-            }
-            Err(e) => Err(e.into()),
-        }
-    }
-
-    /// Binary multiplication with proper refcount handling.
-    ///
-    /// Uses lazy type capture: only calls `py_type()` in error paths.
-    pub(super) fn binary_mult(&mut self) -> Result<(), RunError> {
-        let this = self;
-
-        let rhs = this.pop();
-        defer_drop!(rhs, this);
-        let lhs = this.pop();
-        defer_drop!(lhs, this);
-
-        match lhs.py_mult(rhs, this) {
-            Ok(Some(v)) => {
-                this.push(v);
-                Ok(())
-            }
-            Ok(None) => {
-                let lhs_type = lhs.py_type(this.heap);
-                let rhs_type = rhs.py_type(this.heap);
-                Err(ExcType::binary_type_error("*", lhs_type, rhs_type))
-            }
-            Err(e) => Err(e),
-        }
-    }
-
-    /// Binary division with proper refcount handling.
-    ///
-    /// Uses lazy type capture: only calls `py_type()` in error paths.
-    pub(super) fn binary_div(&mut self) -> Result<(), RunError> {
-        let this = self;
-
-        let rhs = this.pop();
-        defer_drop!(rhs, this);
-        let lhs = this.pop();
-        defer_drop!(lhs, this);
-
-        match lhs.py_div(rhs, this) {
-            Ok(Some(v)) => {
-                this.push(v);
-                Ok(())
-            }
-            Ok(None) => {
-                let lhs_type = lhs.py_type(this.heap);
-                let rhs_type = rhs.py_type(this.heap);
-                Err(ExcType::binary_type_error("/", lhs_type, rhs_type))
-            }
-            Err(e) => Err(e),
-        }
-    }
-
-    /// Binary floor division with proper refcount handling.
-    ///
-    /// Uses lazy type capture: only calls `py_type()` in error paths.
-    pub(super) fn binary_floordiv(&mut self) -> Result<(), RunError> {
-        let this = self;
-
-        let rhs = this.pop();
-        defer_drop!(rhs, this);
-        let lhs = this.pop();
-        defer_drop!(lhs, this);
-
-        match lhs.py_floordiv(rhs, this) {
-            Ok(Some(v)) => {
-                this.push(v);
-                Ok(())
-            }
-            Ok(None) => {
-                let lhs_type = lhs.py_type(this.heap);
-                let rhs_type = rhs.py_type(this.heap);
-                Err(ExcType::binary_type_error("//", lhs_type, rhs_type))
-            }
-            Err(e) => Err(e),
-        }
-    }
-
-    /// Binary modulo with proper refcount handling.
-    ///
-    /// Uses lazy type capture: only calls `py_type()` in error paths.
-    pub(super) fn binary_mod(&mut self) -> Result<(), RunError> {
-        let this = self;
-
-        let rhs = this.pop();
-        defer_drop!(rhs, this);
-        let lhs = this.pop();
-        defer_drop!(lhs, this);
-
-        match lhs.py_mod(rhs, this) {
-            Ok(Some(v)) => {
-                this.push(v);
-                Ok(())
-            }
-            Ok(None) => {
-                let lhs_type = lhs.py_type(this.heap);
-                let rhs_type = rhs.py_type(this.heap);
-                Err(ExcType::binary_type_error("%", lhs_type, rhs_type))
-            }
-            Err(e) => Err(e),
-        }
-    }
-
-    /// Binary power with proper refcount handling.
-    ///
-    /// Uses lazy type capture: only calls `py_type()` in error paths.
-    #[inline(never)]
-    pub(super) fn binary_pow(&mut self) -> Result<(), RunError> {
-        let this = self;
-
-        let rhs = this.pop();
-        defer_drop!(rhs, this);
-        let lhs = this.pop();
-        defer_drop!(lhs, this);
-
-        match lhs.py_pow(rhs, this) {
-            Ok(Some(v)) => {
-                this.push(v);
-                Ok(())
-            }
-            Ok(None) => {
-                let lhs_type = lhs.py_type(this.heap);
-                let rhs_type = rhs.py_type(this.heap);
-                Err(ExcType::binary_type_error("** or pow()", lhs_type, rhs_type))
-            }
-            Err(e) => Err(e),
-        }
-    }
-
-    /// Binary bitwise operation on integers and sets.
-    ///
-    /// For integers, performs standard bitwise operations (AND, OR, XOR, shifts).
-    /// For sets/frozensets, `|` maps to union, `&` to intersection, and `^` to
-    /// symmetric difference. Set operations are handled here because `py_bitwise`
-    /// doesn't have access to `interns`, which set operations need for hashing.
-    pub(super) fn binary_bitwise(&mut self, op: BitwiseOp) -> Result<(), RunError> {
-        let this = self;
-
-        let rhs = this.pop();
-        defer_drop!(rhs, this);
-        let lhs = this.pop();
-        defer_drop!(lhs, this);
-
-        // Set/frozenset operations: |, &, ^ map to union, intersection,
-        // symmetric_difference. Shifts don't apply to sets.
-        let set_op = match op {
-            BitwiseOp::Or => Some(SetBinaryOp::Or),
-            BitwiseOp::And => Some(SetBinaryOp::And),
-            BitwiseOp::Xor => Some(SetBinaryOp::Xor),
-            BitwiseOp::LShift | BitwiseOp::RShift => None,
-        };
-        if let Some(set_op) = set_op
-            && let Some(result) = this.binary_set_op(lhs, rhs, set_op)?
-        {
-            this.push(result);
-            return Ok(());
-        }
-
-        let result = lhs.py_bitwise(rhs, op, this.heap)?;
-        this.push(result);
-        Ok(())
-    }
-
-    /// Binary `&` with CPython-style dict-keys special handling before numeric fallback.
-    ///
-    /// Milestone one only needs one non-numeric behavior here: `dict_keys & iterable`
-    /// should iterate the right-hand side, return a plain `set`, and raise
-    /// `TypeError("'X' object is not iterable")` for non-iterable operands.
-    pub(super) fn binary_and(&mut self) -> Result<(), RunError> {
-        let this = self;
-
-        let rhs = this.pop();
-        defer_drop!(rhs, this);
-        let lhs = this.pop();
-        defer_drop!(lhs, this);
-
-        if let Some(result) = this.binary_dict_view_op(lhs, rhs, DictViewBinaryOp::And)? {
-            this.push(result);
-            return Ok(());
-        }
-
-        if let Some(result) = this.binary_set_op(lhs, rhs, SetBinaryOp::And)? {
-            this.push(result);
-            return Ok(());
-        }
-
-        let result = lhs.py_bitwise(rhs, BitwiseOp::And, this.heap)?;
-        this.push(result);
-        Ok(())
-    }
-
-    /// Binary `|` with CPython-style dict-view handling before numeric fallback.
-    pub(super) fn binary_or(&mut self) -> Result<(), RunError> {
-        let this = self;
-
-        let rhs = this.pop();
-        defer_drop!(rhs, this);
-        let lhs = this.pop();
-        defer_drop!(lhs, this);
-
-        if let Some(result) = this.binary_dict_view_op(lhs, rhs, DictViewBinaryOp::Or)? {
-            this.push(result);
-            return Ok(());
-        }
-
-        if let Some(result) = this.binary_set_op(lhs, rhs, SetBinaryOp::Or)? {
-            this.push(result);
-            return Ok(());
-        }
-
-        let result = lhs.py_bitwise(rhs, BitwiseOp::Or, this.heap)?;
-        this.push(result);
-        Ok(())
-    }
-
-    /// Binary `^` with CPython-style dict-view handling before numeric fallback.
-    pub(super) fn binary_xor(&mut self) -> Result<(), RunError> {
-        let this = self;
-
-        let rhs = this.pop();
-        defer_drop!(rhs, this);
-        let lhs = this.pop();
-        defer_drop!(lhs, this);
-
-        if let Some(result) = this.binary_dict_view_op(lhs, rhs, DictViewBinaryOp::Xor)? {
-            this.push(result);
-            return Ok(());
-        }
-
-        if let Some(result) = this.binary_set_op(lhs, rhs, SetBinaryOp::Xor)? {
-            this.push(result);
-            return Ok(());
-        }
-
-        let result = lhs.py_bitwise(rhs, BitwiseOp::Xor, this.heap)?;
-        this.push(result);
-        Ok(())
-    }
-
-    /// In-place addition (uses py_iadd for mutable containers, falls back to py_add).
-    ///
-    /// For mutable types like lists, `py_iadd` mutates in place and returns true.
-    /// For immutable types, we fall back to regular addition.
-    ///
-    /// Uses lazy type capture: only calls `py_type()` in error paths.
-    ///
-    /// Note: Cannot use `defer_drop!` for `lhs` here because on successful in-place
-    /// operation, we need to push `lhs` back onto the stack rather than drop it.
-    pub(super) fn inplace_add(&mut self) -> Result<(), RunError> {
-        let this = self;
-
-        let rhs = this.pop();
-        defer_drop!(rhs, this);
-        // Use HeapGuard because inplace addition will push lhs back on the stack if successful
-        let mut lhs_guard = HeapGuard::new(this.pop(), this);
-        let (lhs, this) = lhs_guard.as_parts_mut();
-
-        // Try in-place operation first (for mutable types like lists)
-        if lhs.py_iadd(rhs, this, lhs.ref_id())? {
-            // In-place operation succeeded - push lhs back
-            let (lhs, this) = lhs_guard.into_parts();
-            this.push(lhs);
-            return Ok(());
-        }
-
-        // Next try regular addition
-        if let Some(v) = lhs.py_add(rhs, this)? {
-            this.push(v);
-            return Ok(());
-        }
-
-        let lhs_type = lhs.py_type(this.heap);
-        let rhs_type = rhs.py_type(this.heap);
-        Err(ExcType::binary_type_error("+=", lhs_type, rhs_type))
-    }
-
-    /// Binary matrix multiplication (`@` operator).
-    ///
-    /// Currently not implemented - returns a `NotImplementedError`.
-    /// Matrix multiplication requires numpy-like array types which Monty doesn't support.
-    pub(super) fn binary_matmul(&mut self) -> Result<(), RunError> {
-        let rhs = self.pop();
-        let lhs = self.pop();
-        lhs.drop_with_heap(self);
-        rhs.drop_with_heap(self);
-        Err(ExcType::not_implemented("matrix multiplication (@) is not supported").into())
-    }
-
-    /// Implements dict-view set-like operators before falling back to other dispatch.
-    ///
-    /// Returning `Ok(None)` means the left operand was not a set-like dict view, so the
-    /// caller should continue with ordinary numeric or pure-set dispatch.
-    fn binary_dict_view_op(
-        &mut self,
-        lhs: &crate::value::Value,
-        rhs: &crate::value::Value,
-        op: DictViewBinaryOp,
-    ) -> Result<Option<crate::value::Value>, RunError> {
-        let this = self;
-        let crate::value::Value::Ref(lhs_id) = lhs else {
-            return Ok(None);
-        };
-
-        let lhs_set = match this.heap.get(*lhs_id) {
-            HeapData::DictKeysView(view) => view.to_set(this)?,
-            HeapData::DictItemsView(view) => view.to_set(this)?,
-            _ => return Ok(None),
-        };
-        defer_drop!(lhs_set, this);
-
-        let rhs_set = collect_iterable_to_set(rhs.clone_with_heap(this), this)?;
-        defer_drop!(rhs_set, this);
-
-        let result = apply_dict_view_binary_op(lhs_set, rhs_set, op, this)?;
-
-        let result_id = this.heap.allocate(HeapData::Set(result))?;
-        Ok(Some(crate::value::Value::Ref(result_id)))
-    }
-
-    /// Implements pure set/frozenset binary operators with strict operand checks.
-    ///
-    /// Method forms accept arbitrary iterables, but the operator forms handled here
-    /// must reject non-set operands so Monty matches CPython's `TypeError` behavior.
-    fn binary_set_op(
-        &mut self,
-        lhs: &crate::value::Value,
-        rhs: &crate::value::Value,
-        op: SetBinaryOp,
-    ) -> Result<Option<crate::value::Value>, RunError> {
-        let this = self;
-        let crate::value::Value::Ref(lhs_id) = lhs else {
-            return Ok(None);
-        };
-
-        let result = Heap::with_entry_mut(this, *lhs_id, |this, data| match data {
-            crate::heap_data::HeapDataMut::Set(set) => set.binary_op_value(rhs, op, this).map(|v| v.map(HeapData::Set)),
-            crate::heap_data::HeapDataMut::FrozenSet(set) => {
-                set.binary_op_value(rhs, op, this).map(|v| v.map(HeapData::FrozenSet))
-            }
-            _ => Ok(None),
-        })?;
-
-        let Some(result) = result else {
-            return Ok(None);
-        };
-        let result_id = this.heap.allocate(result)?;
-        Ok(Some(crate::value::Value::Ref(result_id)))
-    }
-}
-
-/// Supported dict-view set-like operators.
-#[derive(Debug, Clone, Copy)]
-enum DictViewBinaryOp {
-    And,
-    Or,
-    Xor,
-    Sub,
-}
-
-/// Applies a set-like operator to two temporary sets and returns a plain `set`.
-fn apply_dict_view_binary_op(
-    lhs: &Set,
-    rhs: &Set,
-    op: DictViewBinaryOp,
-    vm: &mut VM<'_, '_, impl ResourceTracker>,
-) -> Result<Set, RunError> {
-    let mut result = match op {
-        DictViewBinaryOp::And => Set::with_capacity(lhs.len().min(rhs.len())),
-        DictViewBinaryOp::Or => Set::with_capacity(lhs.len() + rhs.len()),
-        DictViewBinaryOp::Xor => Set::with_capacity(lhs.len() + rhs.len()),
-        DictViewBinaryOp::Sub => Set::with_capacity(lhs.len()),
-    };
-
-    match op {
-        DictViewBinaryOp::And => {
-            let (smaller, larger) = if lhs.len() <= rhs.len() { (lhs, rhs) } else { (rhs, lhs) };
-            for value in smaller.iter() {
-                if larger.contains(value, vm)? {
-                    result.add(value.clone_with_heap(vm), vm)?;
-                }
-            }
-        }
-        DictViewBinaryOp::Or => {
-            for value in lhs.iter() {
-                result.add(value.clone_with_heap(vm), vm)?;
-            }
-            for value in rhs.iter() {
-                result.add(value.clone_with_heap(vm), vm)?;
-            }
-        }
-        DictViewBinaryOp::Xor => {
-            for value in lhs.iter() {
-                if !rhs.contains(value, vm)? {
-                    result.add(value.clone_with_heap(vm), vm)?;
-                }
-            }
-            for value in rhs.iter() {
-                if !lhs.contains(value, vm)? {
-                    result.add(value.clone_with_heap(vm), vm)?;
-                }
-            }
-        }
-        DictViewBinaryOp::Sub => {
-            for value in lhs.iter() {
-                if !rhs.contains(value, vm)? {
-                    result.add(value.clone_with_heap(vm), vm)?;
-                }
-            }
-        }
-    }
-
-    Ok(result)
-}