Method slot_new

crates/vm/src/exception_group.rs:238–337

(cls: PyTypeRef, args: FuncArgs, vm: &VirtualMachine)

        type Args = crate::function::PosArgs;

        fn slot_new(cls: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
            let args: Self::Args = args.bind(vm)?;
            let args = args.into_vec();
            // Validate exactly 2 positional arguments
            if args.len() != 2 {
                return Err(vm.new_type_error(format!(
                    "BaseExceptionGroup.__new__() takes exactly 2 positional arguments ({} given)",
                    args.len()
                )));
            }

            // Validate message is str
            let message = args[0].clone();
            if !message.fast_isinstance(vm.ctx.types.str_type) {
                return Err(vm.new_type_error(format!(
                    "argument 1 must be str, not {}",
                    message.class().name()
                )));
            }

            // Validate exceptions is a sequence (not set or None)
            let exceptions_arg = &args[1];

            // Check for set/frozenset (not a sequence - unordered)
            if exceptions_arg.fast_isinstance(vm.ctx.types.set_type)
                || exceptions_arg.fast_isinstance(vm.ctx.types.frozenset_type)
            {
                return Err(vm.new_type_error("second argument (exceptions) must be a sequence"));
            }

            // Check for None
            if exceptions_arg.is(&vm.ctx.none) {
                return Err(vm.new_type_error("second argument (exceptions) must be a sequence"));
            }

            let exceptions: Vec<PyObjectRef> = exceptions_arg.try_to_value(vm).map_err(|_| {
                vm.new_type_error("second argument (exceptions) must be a sequence")
            })?;

            // Validate non-empty
            if exceptions.is_empty() {
                return Err(
                    vm.new_value_error("second argument (exceptions) must be a non-empty sequence")
                );
            }

            // Validate all items are BaseException instances
            let mut has_non_exception = false;
            for (i, exc) in exceptions.iter().enumerate() {
                if !exc.fast_isinstance(vm.ctx.exceptions.base_exception_type) {
                    return Err(vm.new_value_error(format!(
                        "Item {} of second argument (exceptions) is not an exception",
                        i
                    )));
                }
                // Check if any exception is not an Exception subclass
                // With dynamic ExceptionGroup (inherits from both BaseExceptionGroup and Exception),
                // ExceptionGroup instances are automatically instances of Exception