superacli 1.1.6 → 1.1.8

package/ref-monty/crates/monty/src/types/long_int.rs

@@ -1,211 +0,0 @@
-//! LongInt wrapper for arbitrary precision integer support.
-//!
-//! This module provides the `LongInt` wrapper type around `num_bigint::BigInt`.
-//! Named `LongInt` to avoid confusion with the external `BigInt` type. Python has
-//! one `int` type, and LongInt is an implementation detail - we use i64 for performance
-//! when values fit, and promote to LongInt on overflow.
-//!
-//! The design centralizes BigInt-related logic into methods on `LongInt` rather than
-//! having freestanding functions scattered across the codebase.
-
-use std::{
-    collections::hash_map::DefaultHasher,
-    fmt::{self, Display},
-    hash::{Hash, Hasher},
-    ops::{Add, Mul, Neg, Sub},
-};
-
-use num_bigint::BigInt;
-use num_traits::{Signed, ToPrimitive, Zero};
-
-use crate::{
-    heap::{Heap, HeapData},
-    resource::{ResourceError, ResourceTracker},
-    value::Value,
-};
-
-/// Wrapper around `num_bigint::BigInt` for arbitrary precision integers.
-///
-/// Named `LongInt` to avoid confusion with the external `BigInt` type from `num_bigint`.
-/// The inner `BigInt` is accessible via `.0` for arithmetic operations that need direct
-/// access to the underlying type.
-///
-/// Python treats all integers as one type - we use `Value::Int(i64)` for values that fit
-/// and `LongInt` for larger values. The `into_value()` method automatically demotes to
-/// i64 when the value fits, maintaining this optimization.
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, serde::Serialize, serde::Deserialize)]
-pub struct LongInt(pub BigInt);
-
-impl LongInt {
-    /// Creates a new `LongInt` from a `BigInt`.
-    pub fn new(bi: BigInt) -> Self {
-        Self(bi)
-    }
-
-    /// Converts to a `Value`, demoting to i64 if it fits.
-    ///
-    /// For performance, we want to keep values as `Value::Int(i64)` whenever possible.
-    /// This method checks if the value fits in an i64 and returns `Value::Int` if so,
-    /// otherwise allocates a `HeapData::LongInt` on the heap.
-    pub fn into_value(self, heap: &mut Heap<impl ResourceTracker>) -> Result<Value, ResourceError> {
-        // Try to demote back to i64 for performance
-        if let Some(i) = self.0.to_i64() {
-            Ok(Value::Int(i))
-        } else {
-            let heap_id = heap.allocate(HeapData::LongInt(self))?;
-            Ok(Value::Ref(heap_id))
-        }
-    }
-
-    /// Computes a hash consistent with i64 hashing.
-    ///
-    /// Critical: For values that fit in i64, this must return the same hash as
-    /// hashing the i64 directly. This ensures dict key consistency - e.g.,
-    /// `hash(5)` must equal `hash(LongInt(5))`.
-    pub fn hash(&self) -> u64 {
-        // If the LongInt fits in i64, hash as i64 for consistency
-        if let Some(i) = self.0.to_i64() {
-            let mut hasher = DefaultHasher::new();
-            // Hash the i64 discriminant and value to match Value::Int hashing
-            std::mem::discriminant(&Value::Int(0)).hash(&mut hasher);
-            i.hash(&mut hasher);
-            hasher.finish()
-        } else {
-            // For LongInts outside i64 range, use byte representation
-            let mut hasher = DefaultHasher::new();
-            // Use a unique discriminant for LongInt (we use the LongInt's sign and bytes)
-            let (sign, bytes) = self.0.to_bytes_le();
-            sign.hash(&mut hasher);
-            bytes.hash(&mut hasher);
-            hasher.finish()
-        }
-    }
-
-    /// Estimates memory size in bytes.
-    ///
-    /// Used for resource tracking. The actual size includes the Vec overhead
-    /// plus the digit storage. Rounds up bits to bytes to avoid underestimating
-    /// (e.g., 1 bit = 1 byte, not 0 bytes).
-    pub fn estimate_size(&self) -> usize {
-        // Each BigInt digit is typically a u32 or u64
-        // We estimate based on the number of significant bits
-        let bits = self.0.bits();
-        // Convert bits to bytes (round up), add overhead for Vec and sign
-        // On 32-bit platforms, truncate to usize::MAX if bits is too large
-        let bit_bytes = usize::try_from(bits).unwrap_or(usize::MAX).saturating_add(7) / 8;
-        bit_bytes + std::mem::size_of::<BigInt>()
-    }
-
-    /// Returns a reference to the inner `BigInt`.
-    ///
-    /// Use this when you need read-only access to the underlying `BigInt`
-    /// for operations like formatting or comparison.
-    pub fn inner(&self) -> &BigInt {
-        &self.0
-    }
-
-    /// Checks if the value is zero.
-    pub fn is_zero(&self) -> bool {
-        self.0.is_zero()
-    }
-
-    /// Checks if the value is negative.
-    pub fn is_negative(&self) -> bool {
-        self.0.is_negative()
-    }
-
-    /// Tries to convert to i64.
-    ///
-    /// Returns `Some(i64)` if the value fits, `None` otherwise.
-    pub fn to_i64(&self) -> Option<i64> {
-        self.0.to_i64()
-    }
-
-    /// Tries to convert to f64.
-    ///
-    /// Returns `Some(f64)` if the conversion is possible, `None` if the value
-    /// is too large to represent as f64.
-    pub fn to_f64(&self) -> Option<f64> {
-        self.0.to_f64()
-    }
-
-    /// Tries to convert to u32.
-    ///
-    /// Returns `Some(u32)` if the value fits, `None` otherwise.
-    pub fn to_u32(&self) -> Option<u32> {
-        self.0.to_u32()
-    }
-
-    /// Tries to convert to usize.
-    ///
-    /// Returns `Some(usize)` if the value fits, `None` otherwise.
-    /// Useful for sequence repetition counts.
-    pub fn to_usize(&self) -> Option<usize> {
-        self.0.to_usize()
-    }
-
-    /// Returns the absolute value as a new `LongInt`.
-    pub fn abs(&self) -> Self {
-        Self(self.0.abs())
-    }
-
-    /// Returns the number of significant bits in this LongInt.
-    ///
-    /// Zero returns 0 bits. For non-zero values, this is the position of the
-    /// highest set bit plus one.
-    pub fn bits(&self) -> u64 {
-        self.0.bits()
-    }
-}
-
-// === Trait Implementations ===
-
-impl From<BigInt> for LongInt {
-    fn from(bi: BigInt) -> Self {
-        Self(bi)
-    }
-}
-
-impl From<i64> for LongInt {
-    fn from(i: i64) -> Self {
-        Self(BigInt::from(i))
-    }
-}
-
-impl Add for LongInt {
-    type Output = Self;
-
-    fn add(self, rhs: Self) -> Self::Output {
-        Self(self.0 + rhs.0)
-    }
-}
-
-impl Sub for LongInt {
-    type Output = Self;
-
-    fn sub(self, rhs: Self) -> Self::Output {
-        Self(self.0 - rhs.0)
-    }
-}
-
-impl Mul for LongInt {
-    type Output = Self;
-
-    fn mul(self, rhs: Self) -> Self::Output {
-        Self(self.0 * rhs.0)
-    }
-}
-
-impl Neg for LongInt {
-    type Output = Self;
-
-    fn neg(self) -> Self::Output {
-        Self(-self.0)
-    }
-}
-
-impl Display for LongInt {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}", self.0)
-    }
-}

package/ref-monty/crates/monty/src/types/mod.rs

@@ -1,48 +0,0 @@
-/// Type definitions for Python runtime values.
-///
-/// This module contains structured types that wrap heap-allocated data
-/// and provide Python-like semantics for operations like append, insert, etc.
-///
-/// The `AbstractValue` trait provides a common interface for all heap-allocated
-/// types, enabling efficient dispatch via `enum_dispatch`.
-pub mod bytes;
-pub mod dataclass;
-pub mod dict;
-pub mod dict_view;
-pub mod iter;
-pub mod list;
-pub mod long_int;
-pub mod module;
-pub mod namedtuple;
-pub mod path;
-pub mod property;
-pub mod py_trait;
-pub mod range;
-pub mod re_match;
-pub mod re_pattern;
-pub mod set;
-pub mod slice;
-pub mod str;
-pub mod tuple;
-pub mod r#type;
-
-pub(crate) use bytes::Bytes;
-pub(crate) use dataclass::Dataclass;
-pub(crate) use dict::Dict;
-pub(crate) use dict_view::{DictItemsView, DictKeysView, DictValuesView};
-pub(crate) use iter::MontyIter;
-pub(crate) use list::List;
-pub(crate) use long_int::LongInt;
-pub(crate) use module::Module;
-pub(crate) use namedtuple::NamedTuple;
-pub(crate) use path::Path;
-pub(crate) use property::Property;
-pub(crate) use py_trait::PyTrait;
-pub(crate) use range::Range;
-pub(crate) use re_match::ReMatch;
-pub(crate) use re_pattern::RePattern;
-pub(crate) use set::{FrozenSet, Set};
-pub(crate) use slice::Slice;
-pub(crate) use str::Str;
-pub(crate) use tuple::{Tuple, allocate_tuple};
-pub(crate) use r#type::Type;

package/ref-monty/crates/monty/src/types/module.rs

@@ -1,146 +0,0 @@
-//! Python module type for representing imported modules.
-
-use crate::{
-    args::ArgValues,
-    bytecode::{CallResult, VM},
-    defer_drop,
-    exception_private::{ExcType, RunResult},
-    heap::{Heap, HeapGuard, HeapId},
-    intern::{Interns, StringId},
-    resource::ResourceTracker,
-    types::{Dict, PyTrait},
-    value::{EitherStr, Value},
-};
-
-/// A Python module with a name and attribute dictionary.
-///
-/// Modules in Monty are simplified compared to CPython - they just have a name
-/// and a dictionary of attributes. This is sufficient for built-in modules like
-/// `sys` and `typing` where we control the available attributes.
-#[derive(Debug, serde::Serialize, serde::Deserialize)]
-pub(crate) struct Module {
-    /// The module name (e.g., "sys", "typing").
-    name: StringId,
-    /// The module's attributes (e.g., `version`, `platform` for `sys`).
-    attrs: Dict,
-}
-
-impl Module {
-    /// Creates a new module with an empty attributes dictionary.
-    ///
-    /// The module name must be pre-interned during the prepare phase.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the module name string has not been pre-interned.
-    pub fn new(name: impl Into<StringId>) -> Self {
-        Self {
-            name: name.into(),
-            attrs: Dict::new(),
-        }
-    }
-
-    /// Returns the module's name StringId.
-    pub fn name(&self) -> StringId {
-        self.name
-    }
-
-    /// Returns a reference to the module's attribute dictionary.
-    pub fn attrs(&self) -> &Dict {
-        &self.attrs
-    }
-
-    /// Sets an attribute in the module's dictionary.
-    ///
-    /// The attribute name must be pre-interned during the prepare phase.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the attribute name string has not been pre-interned.
-    pub fn set_attr(&mut self, name: impl Into<StringId>, value: Value, vm: &mut VM<'_, '_, impl ResourceTracker>) {
-        let key = Value::InternString(name.into());
-        // Unwrap is safe because InternString keys are always hashable
-        self.attrs.set(key, value, vm).unwrap();
-    }
-
-    /// Looks up an attribute by name in the module's attribute dictionary.
-    ///
-    /// Returns `Some(value)` if the attribute exists, `None` otherwise.
-    /// The returned value is cloned with proper refcount handling.
-    pub fn get_attr(&self, attr_value: &Value, vm: &mut VM<'_, '_, impl ResourceTracker>) -> Option<Value> {
-        // Dict::get returns Result because of hash computation, but InternString keys
-        // are always hashable, so `.ok()` is safe here.
-        self.attrs
-            .get(attr_value, vm)
-            .ok()
-            .flatten()
-            .map(|v| v.clone_with_heap(vm))
-    }
-
-    /// Returns whether this module has any heap references in its attributes.
-    pub fn has_refs(&self) -> bool {
-        self.attrs.has_refs()
-    }
-
-    /// Collects child HeapIds for reference counting.
-    pub fn py_dec_ref_ids(&mut self, stack: &mut Vec<HeapId>) {
-        self.attrs.py_dec_ref_ids(stack);
-    }
-
-    /// Gets an attribute by string ID for the `py_getattr` trait method.
-    ///
-    /// Returns the attribute value if found, or `None` if the attribute doesn't exist.
-    /// For `Property` values, invokes the property getter rather than returning
-    /// the Property itself - this implements Python's descriptor protocol.
-    pub fn py_getattr(
-        &self,
-        attr: &EitherStr,
-        heap: &mut Heap<impl ResourceTracker>,
-        interns: &Interns,
-    ) -> Option<CallResult> {
-        let value = self.attrs.get_by_str(attr.as_str(interns), heap, interns)?;
-
-        // If the value is a Property, invoke its getter to compute the actual value
-        if let Value::Property(prop) = *value {
-            Some(prop.get())
-        } else {
-            Some(CallResult::Value(value.clone_with_heap(heap)))
-        }
-    }
-
-    /// Calls an attribute as a function on this module.
-    ///
-    /// Modules don't have methods - they have callable attributes. This looks up
-    /// the attribute and calls it if it's a `ModuleFunction`.
-    ///
-    /// Returns `CallResult` because module functions may need OS operations
-    /// (e.g., `os.getenv()`) that require host involvement.
-    pub fn py_call_attr(
-        &self,
-        _self_id: HeapId,
-        vm: &mut VM<'_, '_, impl ResourceTracker>,
-        attr: &EitherStr,
-        args: ArgValues,
-    ) -> RunResult<CallResult> {
-        let mut args_guard = HeapGuard::new(args, vm);
-        let vm = args_guard.heap();
-        let attr_key = match attr {
-            EitherStr::Interned(id) => Value::InternString(*id),
-            EitherStr::Heap(s) => {
-                return Err(ExcType::attribute_error_module(vm.interns.get_str(self.name), s));
-            }
-        };
-
-        match self.get_attr(&attr_key, vm) {
-            Some(value) => {
-                let (args, vm) = args_guard.into_parts();
-                defer_drop!(value, vm);
-                vm.call_function(value, args)
-            }
-            None => Err(ExcType::attribute_error_module(
-                vm.interns.get_str(self.name),
-                attr.as_str(vm.interns),
-            )),
-        }
-    }
-}

package/ref-monty/crates/monty/src/types/namedtuple.rs

@@ -1,261 +0,0 @@
-/// Python named tuple type, combining tuple-like indexing with named attribute access.
-///
-/// Named tuples are like regular tuples but with field names, providing two ways
-/// to access elements:
-/// - By index: `version_info[0]` returns the major version
-/// - By name: `version_info.major` returns the same value
-///
-/// Named tuples are:
-/// - Immutable (all tuple semantics apply)
-/// - Hashable (if all elements are hashable)
-/// - Have a descriptive repr: `sys.version_info(major=3, minor=14, ...)`
-/// - Support `len()` and iteration
-///
-/// # Use Case
-///
-/// This type is used for `sys.version_info` and similar structured tuples where
-/// named access improves usability and readability.
-use std::fmt::Write;
-
-use ahash::AHashSet;
-
-use super::PyTrait;
-use crate::{
-    bytecode::{CallResult, VM},
-    defer_drop,
-    exception_private::{ExcType, RunResult},
-    heap::{Heap, HeapId},
-    intern::{Interns, StringId},
-    resource::{ResourceError, ResourceTracker},
-    types::Type,
-    value::{EitherStr, Value},
-};
-
-/// Python named tuple value stored on the heap.
-///
-/// Wraps a `Vec<Value>` with associated field names and provides both index-based
-/// and name-based access. Named tuples are conceptually immutable, though this is
-/// not enforced at the type level for internal operations.
-///
-/// # Reference Counting
-///
-/// When a named tuple is freed, all contained heap references have their refcounts
-/// decremented via `py_dec_ref_ids`.
-///
-/// # GC Optimization
-///
-/// The `contains_refs` flag tracks whether the tuple contains any `Value::Ref` items.
-/// This allows `py_dec_ref_ids` to skip iteration when the tuple contains only
-/// primitive values (ints, bools, None, etc.).
-#[derive(Debug, serde::Serialize, serde::Deserialize)]
-pub(crate) struct NamedTuple {
-    /// Type name for repr (e.g., "sys.version_info").
-    name: EitherStr,
-    /// Field names in order, e.g., `major`, `minor`, `micro`, `releaselevel`, `serial`.
-    field_names: Vec<EitherStr>,
-    /// Values in order (same length as field_names).
-    items: Vec<Value>,
-    /// True if any item is a `Value::Ref`. Set at creation time since named tuples are immutable.
-    contains_refs: bool,
-}
-
-impl NamedTuple {
-    /// Creates a new named tuple.
-    ///
-    /// # Arguments
-    ///
-    /// * `type_name` - The type name for repr (e.g., "sys.version_info")
-    /// * `field_names` - Field names as interned StringIds, in order
-    /// * `items` - Values corresponding to each field name
-    ///
-    /// # Panics
-    ///
-    /// Panics if `field_names.len() != items.len()`.
-    #[must_use]
-    pub fn new(name: impl Into<EitherStr>, field_names: Vec<EitherStr>, items: Vec<Value>) -> Self {
-        assert_eq!(
-            field_names.len(),
-            items.len(),
-            "NamedTuple field_names and items must have same length"
-        );
-        let contains_refs = items.iter().any(|v| matches!(v, Value::Ref(_)));
-        Self {
-            name: name.into(),
-            field_names,
-            items,
-            contains_refs,
-        }
-    }
-
-    /// Returns the type name (e.g., "sys.version_info").
-    #[must_use]
-    pub fn name<'a>(&'a self, interns: &'a Interns) -> &'a str {
-        self.name.as_str(interns)
-    }
-
-    /// Returns a reference to the field names.
-    #[must_use]
-    pub fn field_names(&self) -> &[EitherStr] {
-        &self.field_names
-    }
-
-    /// Returns a reference to the underlying items vector.
-    #[must_use]
-    pub fn as_vec(&self) -> &Vec<Value> {
-        &self.items
-    }
-
-    /// Returns the number of elements.
-    #[must_use]
-    pub fn len(&self) -> usize {
-        self.items.len()
-    }
-
-    /// Returns whether the tuple contains any heap references.
-    ///
-    /// When false, `py_dec_ref_ids` can skip iteration.
-    #[inline]
-    #[must_use]
-    pub fn contains_refs(&self) -> bool {
-        self.contains_refs
-    }
-
-    /// Gets a field value by name.
-    ///
-    /// Compares field names by actual string content, not just variant type.
-    /// This allows lookup to work regardless of whether the field name was
-    /// stored as an interned `StringId` or a heap-allocated `String`.
-    ///
-    /// Returns `Some(value)` if the field exists, `None` otherwise.
-    #[must_use]
-    pub fn get_by_name(&self, name_str: &str, interns: &Interns) -> Option<&Value> {
-        self.field_names
-            .iter()
-            .position(|field_name| field_name.as_str(interns) == name_str)
-            .map(|idx| &self.items[idx])
-    }
-
-    /// Gets a field value by index, supporting negative indexing.
-    ///
-    /// Returns `Some(value)` if the index is in bounds, `None` otherwise.
-    /// Uses `index + len` instead of `-index` to avoid overflow on `i64::MIN`.
-    #[must_use]
-    pub fn get_by_index(&self, index: i64) -> Option<&Value> {
-        let len = i64::try_from(self.items.len()).ok()?;
-        let normalized = if index < 0 { index + len } else { index };
-        if normalized < 0 || normalized >= len {
-            return None;
-        }
-        self.items.get(usize::try_from(normalized).ok()?)
-    }
-}
-
-impl PyTrait for NamedTuple {
-    fn py_type(&self, _heap: &Heap<impl ResourceTracker>) -> Type {
-        Type::NamedTuple
-    }
-
-    fn py_estimate_size(&self) -> usize {
-        std::mem::size_of::<Self>()
-            + self.name.py_estimate_size()
-            + self.field_names.len() * std::mem::size_of::<StringId>()
-            + self.items.len() * std::mem::size_of::<Value>()
-    }
-
-    fn py_len(&self, _vm: &VM<'_, '_, impl ResourceTracker>) -> Option<usize> {
-        Some(self.items.len())
-    }
-
-    fn py_getitem(&self, key: &Value, vm: &mut VM<'_, '_, impl ResourceTracker>) -> RunResult<Value> {
-        // Extract integer index from key, returning TypeError if not an int
-        let index = match key {
-            Value::Int(i) => *i,
-            _ => return Err(ExcType::type_error_indices(Type::NamedTuple, key.py_type(vm.heap))),
-        };
-
-        // Get by index with bounds checking
-        match self.get_by_index(index) {
-            Some(value) => Ok(value.clone_with_heap(vm.heap)),
-            None => Err(ExcType::tuple_index_error()),
-        }
-    }
-
-    fn py_eq(&self, other: &Self, vm: &mut VM<'_, '_, impl ResourceTracker>) -> Result<bool, ResourceError> {
-        // Compare only by items (not type_name) to match tuple semantics
-        // This allows sys.version_info == (3, 14, 0, 'final', 0) to work
-        if self.items.len() != other.items.len() {
-            return Ok(false);
-        }
-        let token = vm.heap.incr_recursion_depth()?;
-        defer_drop!(token, vm);
-        for (i1, i2) in self.items.iter().zip(&other.items) {
-            if !i1.py_eq(i2, vm)? {
-                return Ok(false);
-            }
-        }
-        Ok(true)
-    }
-
-    /// Pushes all heap IDs contained in this named tuple onto the stack.
-    ///
-    /// Called during garbage collection to decrement refcounts of nested values.
-    /// When `ref-count-panic` is enabled, also marks all Values as Dereferenced.
-    fn py_dec_ref_ids(&mut self, stack: &mut Vec<HeapId>) {
-        // Skip iteration if no refs - GC optimization for tuples of primitives
-        if !self.contains_refs {
-            return;
-        }
-        for obj in &mut self.items {
-            if let Value::Ref(id) = obj {
-                stack.push(*id);
-                #[cfg(feature = "ref-count-panic")]
-                obj.dec_ref_forget();
-            }
-        }
-    }
-
-    fn py_bool(&self, _vm: &VM<'_, '_, impl ResourceTracker>) -> bool {
-        !self.items.is_empty()
-    }
-
-    fn py_repr_fmt(
-        &self,
-        f: &mut impl Write,
-        vm: &VM<'_, '_, impl ResourceTracker>,
-        heap_ids: &mut AHashSet<HeapId>,
-    ) -> std::fmt::Result {
-        // Check depth limit before recursing
-        let heap = &*vm.heap;
-        let Some(token) = heap.incr_recursion_depth_for_repr() else {
-            return f.write_str("...");
-        };
-        crate::defer_drop_immutable_heap!(token, heap);
-
-        // Format: type_name(field1=value1, field2=value2, ...)
-        write!(f, "{}(", self.name.as_str(vm.interns))?;
-
-        let mut first = true;
-        for (field_name, value) in self.field_names.iter().zip(&self.items) {
-            if !first {
-                f.write_str(", ")?;
-            }
-            first = false;
-            f.write_str(field_name.as_str(vm.interns))?;
-            f.write_char('=')?;
-            value.py_repr_fmt(f, vm, heap_ids)?;
-        }
-
-        f.write_char(')')?;
-        Ok(())
-    }
-
-    fn py_getattr(&self, attr: &EitherStr, vm: &mut VM<'_, '_, impl ResourceTracker>) -> RunResult<Option<CallResult>> {
-        let attr_name = attr.as_str(vm.interns);
-        if let Some(value) = self.get_by_name(attr_name, vm.interns) {
-            Ok(Some(CallResult::Value(value.clone_with_heap(vm.heap))))
-        } else {
-            // we use name here, not `self.py_type(heap)` hence returning a Ok(None)
-            Err(ExcType::attribute_error(self.name(vm.interns), attr_name))
-        }
-    }
-}