superacli 1.1.4 → 1.1.6

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

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

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

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

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