superacli 1.1.5 → 1.1.7

package/ref-monty/crates/monty/src/signature.rs

@@ -1,651 +0,0 @@
-//! Function signature representation and argument binding.
-//!
-//! This module handles Python function signatures including all parameter types:
-//! positional-only, positional-or-keyword, *args, keyword-only, and **kwargs.
-//! It also handles default values and the argument binding algorithm.
-
-use crate::{
-    args::{ArgPosIter, ArgValues},
-    bytecode::VM,
-    defer_drop_mut,
-    exception_private::{ExcType, RunResult, SimpleException},
-    expressions::Identifier,
-    heap::{HeapData, HeapGuard},
-    intern::{Interns, StringId},
-    resource::ResourceTracker,
-    types::{Dict, allocate_tuple},
-    value::Value,
-};
-
-/// Represents a Python function signature with all parameter types.
-///
-/// A complete Python signature can include:
-/// - Positional-only parameters (before `/`)
-/// - Positional-or-keyword parameters (regular parameters)
-/// - Variable positional parameter (`*args`)
-/// - Keyword-only parameters (after `*` or `*args`)
-/// - Variable keyword parameter (`**kwargs`)
-///
-/// # Default Values
-///
-/// Default values are tracked by count per parameter group. The `*_defaults_count` fields
-/// indicate how many parameters (from the end of each group) have defaults. For example,
-/// if `args = [a, b, c]` and `arg_defaults_count = 2`, then `b` and `c` have defaults.
-///
-/// Note: The actual default Values are evaluated at function definition time and stored
-/// separately (in the heap as part of the function/closure object). This struct only
-/// tracks the structure, not the values themselves.
-///
-/// # Namespace Layout
-///
-/// Parameters are laid out in the namespace in this order:
-/// ```text
-/// [pos_args][args][*args_slot?][kwargs][**kwargs_slot?]
-/// ```
-/// The `*args` slot is only present if `var_args` is Some.
-/// The `**kwargs` slot is only present if `var_kwargs` is Some.
-#[derive(Debug, Clone, Default, serde::Serialize, serde::Deserialize)]
-pub(crate) struct Signature {
-    /// Positional-only parameters, e.g. `a, b` in `def f(a, b, /): ...`
-    ///
-    /// These can only be passed by position, not by keyword.
-    pos_args: Option<Vec<StringId>>,
-
-    /// Number of positional-only parameters with defaults (from the end).
-    pos_defaults_count: usize,
-
-    /// Positional-or-keyword parameters, e.g. `a, b` in `def f(a, b): ...`
-    ///
-    /// These can be passed either by position or by keyword.
-    args: Option<Vec<StringId>>,
-
-    /// Number of positional-or-keyword parameters with defaults (from the end).
-    arg_defaults_count: usize,
-
-    /// Variable positional parameter name, e.g. `args` in `def f(*args): ...`
-    ///
-    /// Collects excess positional arguments into a tuple.
-    var_args: Option<StringId>,
-
-    /// Keyword-only parameters, e.g. `c` in `def f(*, c): ...` or `def f(*args, c): ...`
-    ///
-    /// These can only be passed by keyword, not by position.
-    kwargs: Option<Vec<StringId>>,
-
-    /// Mapping from each keyword-only parameter to its default index (if any).
-    ///
-    /// Each entry corresponds to the same index in `kwargs`. A value of `Some(i)`
-    /// points into the kwarg section of the defaults array, while `None` means
-    /// the parameter is required.
-    kwarg_default_map: Option<Vec<Option<usize>>>,
-
-    /// Variable keyword parameter name, e.g. `kwargs` in `def f(**kwargs): ...`
-    ///
-    /// Collects excess keyword arguments into a dict.
-    var_kwargs: Option<StringId>,
-
-    /// How simple the signature is, used for fast path when binding
-    bind_mode: BindMode,
-}
-
-#[derive(Debug, Clone, Default, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
-enum BindMode {
-    /// If this is a simple signature (no defaults, no *args/**kwargs).
-    ///
-    /// Simple signatures can use a fast path for argument binding that avoids
-    /// the full binding algorithm overhead. A simple signature has:
-    /// - No positional-only parameters
-    /// - No defaults for any parameters
-    /// - No *args or **kwargs
-    /// - No keyword-only parameters
-    #[default]
-    Simple,
-    /// If this signature has only positional-or-keyword params with defaults.
-    ///
-    /// This identifies the common pattern `def f(a, b=1, c=2)` where:
-    /// - No positional-only parameters
-    /// - No *args or **kwargs
-    /// - No keyword-only parameters
-    /// - Has some default values
-    ///
-    /// These signatures can use a simplified binding that just fills positional
-    /// args and applies defaults without the full algorithm overhead.
-    SimpleWithDefaults,
-    Complex,
-}
-
-impl Signature {
-    /// Creates a full signature with all parameter types.
-    ///
-    /// # Arguments
-    /// * `pos_args` - Positional-only parameter names
-    /// * `pos_defaults_count` - Number of pos_args with defaults (from end)
-    /// * `args` - Positional-or-keyword parameter names
-    /// * `arg_defaults_count` - Number of args with defaults (from end)
-    /// * `var_args` - Variable positional parameter name (*args)
-    /// * `kwargs` - Keyword-only parameter names
-    /// * `kwarg_default_map` - Mapping of kw-only parameters to default indices
-    /// * `var_kwargs` - Variable keyword parameter name (**kwargs)
-    #[expect(clippy::too_many_arguments)]
-    pub fn new(
-        pos_args: Vec<StringId>,
-        pos_defaults_count: usize,
-        args: Vec<StringId>,
-        arg_defaults_count: usize,
-        var_args: Option<StringId>,
-        kwargs: Vec<StringId>,
-        kwarg_default_map: Vec<Option<usize>>,
-        var_kwargs: Option<StringId>,
-    ) -> Self {
-        let pos_args = if pos_args.is_empty() { None } else { Some(pos_args) };
-        let has_kwonly = !kwargs.is_empty();
-        let kwargs = if has_kwonly { Some(kwargs) } else { None };
-
-        let bind_mode = if pos_args.is_none()
-            && pos_defaults_count == 0
-            && arg_defaults_count == 0
-            && var_args.is_none()
-            && kwargs.is_none()
-            && var_kwargs.is_none()
-        {
-            BindMode::Simple
-        } else if pos_args.is_none()
-            && var_args.is_none()
-            && kwargs.is_none()
-            && var_kwargs.is_none()
-            && arg_defaults_count > 0
-        {
-            BindMode::SimpleWithDefaults
-        } else {
-            BindMode::Complex
-        };
-
-        Self {
-            pos_args,
-            pos_defaults_count,
-            args: if args.is_empty() { None } else { Some(args) },
-            arg_defaults_count,
-            var_args,
-            kwargs,
-            kwarg_default_map: if has_kwonly { Some(kwarg_default_map) } else { None },
-            var_kwargs,
-            bind_mode,
-        }
-    }
-
-    /// Binds arguments to parameters according to Python's calling conventions.
-    ///
-    /// This implements the full argument binding algorithm:
-    /// 1. Bind positional args to pos_args, then args (in order)
-    /// 2. Bind keyword args to args and kwargs (NOT pos_args - positional-only)
-    /// 3. Collect excess positional args into *args tuple
-    /// 4. Collect excess keyword args into **kwargs dict
-    /// 5. Apply defaults for missing parameters
-    ///
-    /// Returns a Vec<Value> ready to be injected into the namespace, laid out as:
-    /// `[pos_args][args][*args_slot?][kwargs][**kwargs_slot?]`
-    ///
-    /// # Arguments
-    /// * `args` - The arguments from the call site
-    /// * `defaults` - Evaluated default values (layout: pos_defaults, arg_defaults, kwarg_defaults)
-    /// * `heap` - The heap for allocating *args tuple and **kwargs dict
-    /// * `interns` - For looking up parameter names in error messages
-    /// * `func_name` - Function name for error messages
-    /// * `namespace` - The namespace to populate with bound arguments. This is mutated in place and will need to be cleaned up on error.
-    ///
-    /// # Errors
-    /// Returns an error if:
-    /// - Too few or too many positional arguments
-    /// - Missing required keyword-only arguments
-    /// - Unexpected keyword argument
-    /// - Positional-only parameter passed as keyword
-    /// - Same argument passed both positionally and by keyword
-    pub fn bind(
-        &self,
-        args: ArgValues,
-        defaults: &[Value],
-        vm: &mut VM<'_, '_, impl ResourceTracker>,
-        func_name: Identifier,
-        namespace: &mut Vec<Value>,
-    ) -> RunResult<()> {
-        let (pos_iter, keyword_args) = args.into_parts();
-
-        // Convert kwargs to an iterator and guard it so remaining items are cleaned up
-        // on any error path
-        let kwonly_given = keyword_args.len();
-        let keyword_args = keyword_args.into_iter();
-        defer_drop_mut!(keyword_args, vm);
-
-        let namespace_base = namespace.len();
-
-        // Fast path for simple signatures (no defaults, no special params) and
-        // signatures with only positional-or-keyword params and defaults.
-        // This avoids the full binding algorithm overhead for common cases.
-
-        if matches!(self.bind_mode, BindMode::Simple | BindMode::SimpleWithDefaults) && kwonly_given == 0 {
-            match pos_iter {
-                ArgPosIter::Empty => {}
-                ArgPosIter::One(a) => {
-                    namespace.push(a);
-                }
-                ArgPosIter::Two([a1, a2]) => {
-                    namespace.push(a1);
-                    namespace.push(a2);
-                }
-                ArgPosIter::Vec(args) => {
-                    namespace.extend(args);
-                }
-            }
-
-            let actual_count = namespace.len() - namespace_base;
-            let param_count = self.param_count();
-
-            if actual_count == param_count {
-                // Exact match - no defaults needed
-                return Ok(());
-            } else if self.bind_mode == BindMode::SimpleWithDefaults {
-                let required = self.required_positional_count();
-                if actual_count >= required && actual_count < param_count {
-                    // Apply defaults for remaining parameters
-                    // Defaults are stored at the end of the defaults array for pos-or-kw params
-                    let defaults_needed = param_count - actual_count;
-                    let defaults_start = self.arg_defaults_count - defaults_needed;
-                    for i in 0..defaults_needed {
-                        namespace.push(defaults[defaults_start + i].clone_with_heap(vm));
-                    }
-                    return Ok(());
-                }
-            }
-
-            return self.wrong_arg_count_error(actual_count, vm.interns, func_name);
-        }
-
-        // Full binding algorithm for complex signatures or kwargs
-        // Extract interns before guards since HeapGuard borrows the full VM mutably
-        // but we only need mutable access to the heap portion.
-        let mut pos_iter_guard = HeapGuard::new(pos_iter, vm);
-        let (pos_iter, vm) = pos_iter_guard.as_parts_mut();
-
-        // Calculate how many positional params we have
-        let pos_param_count = self.pos_arg_count();
-        let arg_param_count = self.arg_count();
-        let total_positional_params = pos_param_count + arg_param_count;
-
-        // Check positional argument count against maximum
-        if let Some(max) = self.max_positional_count() {
-            let positional_count = pos_iter.len();
-            if positional_count > max {
-                let func = vm.interns.get_str(func_name.name_id);
-                return Err(ExcType::type_error_too_many_positional(
-                    func,
-                    max,
-                    positional_count,
-                    kwonly_given,
-                ));
-            }
-        }
-
-        // Initialize result namespace with Undefined values for all slots
-        // Layout: [pos_args][args][*args?][kwargs][**kwargs?]
-        let var_args_offset = usize::from(self.var_args.is_some());
-        namespace.resize_with(namespace.len() + self.total_slots(), || Value::Undefined);
-
-        // Track which parameters have been bound (for duplicate detection)
-        // Uses a u64 bitmap - supports up to 64 named parameters which is sufficient
-        // for any reasonable Python function (Python itself has practical limits).
-        // Note: this tracks only named params, not *args/**kwargs slots
-        let mut bound_params: u64 = 0;
-
-        // 1. Bind positional args to pos_args, then args
-
-        // Bind to pos_args
-        for (i, slot) in namespace[namespace_base..].iter_mut().enumerate().take(pos_param_count) {
-            if let Some(val) = pos_iter.next() {
-                *slot = val;
-                bound_params |= 1 << i;
-            }
-        }
-
-        // Bind to args
-        for (i, slot) in namespace[namespace_base..]
-            .iter_mut()
-            .enumerate()
-            .take(total_positional_params)
-            .skip(pos_param_count)
-        {
-            if let Some(val) = pos_iter.next() {
-                *slot = val;
-                bound_params |= 1 << i;
-            }
-        }
-
-        // 2. Collect excess positional args into *args tuple
-        if self.var_args.is_some() {
-            namespace[namespace_base + total_positional_params] = allocate_tuple(pos_iter.collect(), vm.heap)?;
-        } else {
-            // If no *args, excess was already checked above via max_positional_count
-            debug_assert_eq!(pos_iter.len(), 0);
-        }
-
-        // 3. Bind keyword args
-        // Bind keywords to args and kwargs (not pos_args - those are positional-only)
-        let mut excess_kwargs_guard = HeapGuard::new(self.var_kwargs.is_some().then(Dict::new), vm);
-        let (excess_kwargs, vm) = excess_kwargs_guard.as_parts_mut();
-
-        'kwargs: for (key, value) in keyword_args {
-            // Guard key: dropped on most paths, consumed into **kwargs via into_parts().
-            let mut key_guard = HeapGuard::new(key, vm);
-            let (key, vm) = key_guard.as_parts_mut();
-
-            // Guard value: consumed into namespace/excess_kwargs via into_inner(),
-            // or dropped automatically on error paths.
-            let mut value_guard = HeapGuard::new(value, vm);
-            let vm = value_guard.heap();
-
-            let Some(keyword_name) = key.as_either_str(vm.heap) else {
-                return Err(ExcType::type_error("keywords must be strings"));
-            };
-
-            // Check if this keyword matches a positional-only param (error)
-            if let Some(pos_args) = &self.pos_args
-                && let Some(&param_id) = pos_args
-                    .iter()
-                    .find(|&&param_id| keyword_name.matches(param_id, vm.interns))
-            {
-                let func = vm.interns.get_str(func_name.name_id);
-                let param = vm.interns.get_str(param_id);
-                return Err(ExcType::type_error_positional_only(func, param));
-            }
-
-            // Try positional-or-keyword params
-            if let Some(args) = &self.args {
-                for (i, &param_id) in args.iter().enumerate() {
-                    if keyword_name.matches(param_id, vm.interns) {
-                        let ns_idx = pos_param_count + i;
-                        if (bound_params & (1 << ns_idx)) != 0 {
-                            let func = vm.interns.get_str(func_name.name_id);
-                            let param = vm.interns.get_str(param_id);
-                            return Err(ExcType::type_error_duplicate_arg(func, param));
-                        }
-                        let (value, _) = value_guard.into_parts();
-                        namespace[namespace_base + ns_idx] = value;
-                        bound_params |= 1 << ns_idx;
-                        continue 'kwargs;
-                    }
-                }
-            }
-
-            // Try keyword-only params
-            if let Some(kwargs) = &self.kwargs {
-                for (i, &param_id) in kwargs.iter().enumerate() {
-                    if keyword_name.matches(param_id, vm.interns) {
-                        let ns_idx = total_positional_params + var_args_offset + i;
-                        let bit_idx = total_positional_params + i;
-                        if (bound_params & (1 << bit_idx)) != 0 {
-                            let func = vm.interns.get_str(func_name.name_id);
-                            let param = vm.interns.get_str(param_id);
-                            return Err(ExcType::type_error_duplicate_arg(func, param));
-                        }
-                        let (value, _) = value_guard.into_parts();
-                        namespace[namespace_base + ns_idx] = value;
-                        bound_params |= 1 << bit_idx;
-                        continue 'kwargs;
-                    }
-                }
-            }
-
-            if let Some(excess_kwargs) = excess_kwargs {
-                // Consume both value and key into **kwargs dict
-                let (value, _) = value_guard.into_parts();
-                let (key, vm) = key_guard.into_parts();
-                excess_kwargs.set(key, value, vm)?;
-                continue 'kwargs;
-            }
-
-            let func = vm.interns.get_str(func_name.name_id);
-            let key_str = keyword_name.as_str(vm.interns);
-            return Err(ExcType::type_error_unexpected_keyword(func, key_str));
-        }
-
-        // 3.5. Apply default values to unbound optional parameters
-        // Defaults layout: [pos_defaults...][arg_defaults...][kwarg_defaults...]
-        // Each section only contains defaults for params that have them.
-        let mut default_idx = 0;
-
-        // Apply pos_args defaults (optional params at the end of pos_args)
-        if self.pos_defaults_count > 0 {
-            let first_optional = pos_param_count - self.pos_defaults_count;
-            for i in first_optional..pos_param_count {
-                if (bound_params & (1 << i)) == 0 {
-                    namespace[namespace_base + i] = defaults[default_idx + (i - first_optional)].clone_with_heap(vm);
-                    bound_params |= 1 << i;
-                }
-            }
-        }
-        default_idx += self.pos_defaults_count;
-
-        // Apply args defaults (optional params at the end of args)
-        if self.arg_defaults_count > 0 {
-            let first_optional = arg_param_count - self.arg_defaults_count;
-            for i in first_optional..arg_param_count {
-                let ns_idx = pos_param_count + i;
-                if (bound_params & (1 << ns_idx)) == 0 {
-                    namespace[namespace_base + ns_idx] =
-                        defaults[default_idx + (i - first_optional)].clone_with_heap(vm);
-                    bound_params |= 1 << ns_idx;
-                }
-            }
-        }
-        default_idx += self.arg_defaults_count;
-
-        // Apply kwargs defaults using the explicit default map
-        if let Some(ref default_map) = self.kwarg_default_map {
-            for (i, default_slot) in default_map.iter().enumerate() {
-                if let Some(slot_idx) = default_slot {
-                    let bound_idx = total_positional_params + i;
-                    // Skip past *args slot if present
-                    let ns_idx = total_positional_params + var_args_offset + i;
-                    if (bound_params & (1 << bound_idx)) == 0 {
-                        namespace[namespace_base + ns_idx] = defaults[default_idx + slot_idx].clone_with_heap(vm);
-                        bound_params |= 1 << bound_idx;
-                    }
-                }
-            }
-        }
-
-        // 4. Check that all required params are bound BEFORE building final namespace.
-        // This ensures we can clean up properly on error without leaking heap values.
-
-        // Check required positional params (pos_args + required args)
-        let mut missing_positional: Vec<&str> = Vec::new();
-
-        // Check pos_args
-        if let Some(ref pos_args) = self.pos_args {
-            let required_pos_only = pos_args.len().saturating_sub(self.pos_defaults_count);
-            for (i, &param_id) in pos_args.iter().enumerate() {
-                if i < required_pos_only && (bound_params & (1 << i)) == 0 {
-                    missing_positional.push(vm.interns.get_str(param_id));
-                }
-            }
-        }
-
-        // Check args (positional-or-keyword)
-        if let Some(ref args_params) = self.args {
-            let required_args = args_params.len().saturating_sub(self.arg_defaults_count);
-            for (i, &param_id) in args_params.iter().enumerate() {
-                if i < required_args && (bound_params & (1 << (pos_param_count + i))) == 0 {
-                    missing_positional.push(vm.interns.get_str(param_id));
-                }
-            }
-        }
-
-        if !missing_positional.is_empty() {
-            // Clean up bound values before returning error
-            let func = vm.interns.get_str(func_name.name_id);
-            return Err(ExcType::type_error_missing_positional_with_names(
-                func,
-                &missing_positional,
-            ));
-        }
-
-        // Check required keyword-only args
-        let mut missing_kwonly: Vec<&str> = Vec::new();
-        if let Some(ref kwargs_params) = self.kwargs {
-            let default_map = self.kwarg_default_map.as_ref();
-            for (i, &param_id) in kwargs_params.iter().enumerate() {
-                let has_default = default_map.and_then(|map| map.get(i)).is_some_and(Option::is_some);
-                if !has_default && (bound_params & (1 << (total_positional_params + i))) == 0 {
-                    missing_kwonly.push(vm.interns.get_str(param_id));
-                }
-            }
-        }
-
-        if !missing_kwonly.is_empty() {
-            let func = vm.interns.get_str(func_name.name_id);
-            return Err(ExcType::type_error_missing_kwonly_with_names(func, &missing_kwonly));
-        }
-
-        // 5. Insert **kwargs dict if present (at the last slot)
-        // Namespace layout: [pos_args][args][*args?][kwargs][**kwargs?]
-        let (excess_kwargs, vm) = excess_kwargs_guard.into_parts();
-        if let Some(excess_kwargs) = excess_kwargs {
-            let dict_id = vm.heap.allocate(HeapData::Dict(excess_kwargs))?;
-            let last_slot = namespace.len() - 1;
-            namespace[last_slot] = Value::Ref(dict_id);
-        }
-
-        Ok(())
-    }
-
-    /// Returns the total number of named parameters (excluding *args/**kwargs slots).
-    ///
-    /// This is `pos_args.len() + args.len() + kwargs.len()`.
-    pub fn param_count(&self) -> usize {
-        self.pos_arg_count() + self.arg_count() + self.kwarg_count()
-    }
-
-    /// Returns the total number of namespace slots needed for parameters.
-    ///
-    /// This includes slots for:
-    /// - All named parameters (pos_args + args + kwargs)
-    /// - The *args tuple (if var_args is Some)
-    /// - The **kwargs dict (if var_kwargs is Some)
-    pub fn total_slots(&self) -> usize {
-        let mut slots = self.param_count();
-        if self.var_args.is_some() {
-            slots += 1;
-        }
-        if self.var_kwargs.is_some() {
-            slots += 1;
-        }
-        slots
-    }
-
-    /// Returns the total number of default values across all parameter groups.
-    pub fn total_defaults_count(&self) -> usize {
-        self.pos_defaults_count + self.arg_defaults_count + self.kwarg_defaults_count()
-    }
-
-    /// Returns the minimum number of positional arguments required.
-    ///
-    /// This is the total positional param count minus the number of defaults.
-    /// For a signature like `def f(a, b, c=1)`, this returns 2 (a and b are required).
-    #[inline]
-    fn required_positional_count(&self) -> usize {
-        self.pos_arg_count() + self.arg_count() - self.pos_defaults_count - self.arg_defaults_count
-    }
-
-    fn kwarg_defaults_count(&self) -> usize {
-        self.kwarg_default_map
-            .as_deref()
-            .map(|v| v.iter().filter(|&x| x.is_some()).count())
-            .unwrap_or_default()
-    }
-
-    /// Returns the number of positional-only parameters.
-    fn pos_arg_count(&self) -> usize {
-        self.pos_args.as_ref().map_or(0, Vec::len)
-    }
-
-    /// Returns the number of positional-or-keyword parameters.
-    fn arg_count(&self) -> usize {
-        self.args.as_ref().map_or(0, Vec::len)
-    }
-
-    /// Returns the number of keyword-only parameters.
-    fn kwarg_count(&self) -> usize {
-        self.kwargs.as_ref().map_or(0, Vec::len)
-    }
-
-    /// Returns an iterator over all parameter names in namespace slot order.
-    ///
-    /// Order: pos_args, args, var_args (if present), kwargs, var_kwargs (if present)
-    fn param_names(&self) -> impl Iterator<Item = StringId> + '_ {
-        let pos_args = self.pos_args.iter().flat_map(|v| v.iter().copied());
-        let args = self.args.iter().flat_map(|v| v.iter().copied());
-        let var_args = self.var_args.iter().copied();
-        let kwargs = self.kwargs.iter().flat_map(|v| v.iter().copied());
-        let var_kwargs = self.var_kwargs.iter().copied();
-
-        pos_args.chain(args).chain(var_args).chain(kwargs).chain(var_kwargs)
-    }
-
-    /// Returns the maximum number of positional arguments accepted.
-    ///
-    /// Returns None if *args is present (unlimited positional args).
-    fn max_positional_count(&self) -> Option<usize> {
-        if self.var_args.is_some() {
-            None
-        } else {
-            Some(self.pos_arg_count() + self.arg_count())
-        }
-    }
-
-    /// Creates an error for wrong number of arguments.
-    ///
-    /// Handles both "missing required positional arguments" and "too many arguments" cases,
-    /// formatting the error message to match CPython's style.
-    ///
-    /// # Arguments
-    /// * `actual_count` - Number of arguments actually provided
-    /// * `interns` - String storage for looking up interned names
-    fn wrong_arg_count_error<T>(&self, actual_count: usize, interns: &Interns, func_name: Identifier) -> RunResult<T> {
-        let name_str = interns.get_str(func_name.name_id);
-        let param_count = self.param_count();
-        let msg = if let Some(missing_count) = param_count.checked_sub(actual_count) {
-            // Missing arguments - show actual parameter names
-            let mut msg = format!(
-                "{}() missing {} required positional argument{}: ",
-                name_str,
-                missing_count,
-                if missing_count == 1 { "" } else { "s" }
-            );
-            // Collect parameter names, skipping the ones already provided
-            let mut missing_names: Vec<_> = self
-                .param_names()
-                .skip(actual_count)
-                .map(|string_id| format!("'{}'", interns.get_str(string_id)))
-                .collect();
-            let last = missing_names.pop().unwrap();
-            if !missing_names.is_empty() {
-                msg.push_str(&missing_names.join(", "));
-                msg.push_str(", and ");
-            }
-            msg.push_str(&last);
-            msg
-        } else {
-            // Too many arguments
-            format!(
-                "{}() takes {} positional argument{} but {} {} given",
-                name_str,
-                param_count,
-                if param_count == 1 { "" } else { "s" },
-                actual_count,
-                if actual_count == 1 { "was" } else { "were" }
-            )
-        };
-        Err(SimpleException::new_msg(ExcType::TypeError, msg)
-            .with_position(func_name.position)
-            .into())
-    }
-}