RustPython
diff --git a/‎crates/derive-impl/src/pyclass.rs‎
Lines changed: 4 additions & 30 deletions b/‎crates/derive-impl/src/pyclass.rs‎
Lines changed: 4 additions & 30 deletions
diff --git a/‎crates/stdlib/src/hashlib.rs‎
Lines changed: 1 addition & 1 deletion b/‎crates/stdlib/src/hashlib.rs‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎crates/stdlib/src/ssl/error.rs‎
Lines changed: 1 addition & 1 deletion b/‎crates/stdlib/src/ssl/error.rs‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎crates/vm/src/exception_group.rs‎
Lines changed: 12 additions & 2 deletions b/‎crates/vm/src/exception_group.rs‎
Lines changed: 12 additions & 2 deletions
diff --git a/‎crates/vm/src/exceptions.rs‎
Lines changed: 90 additions & 39 deletions b/‎crates/vm/src/exceptions.rs‎
Lines changed: 90 additions & 39 deletions
diff --git a/‎extra_tests/snippets/builtin_exceptions.py‎
Lines changed: 27 additions & 12 deletions b/‎extra_tests/snippets/builtin_exceptions.py‎
Lines changed: 27 additions & 12 deletions
@@ -778,36 +778,10 @@ pub(crate) fn impl_pyexception_impl(attr: PunctuatedNestedMeta, item: Item) -> R
         }
     };
 
-    // We need this method, because of how `CPython` copies `__init__`
-    // from `BaseException` in `SimpleExtendsException` macro.
-    // See: `(initproc)BaseException_init`
-    // spell-checker:ignore initproc
-    let slot_init = if with_contains(&with_items, "Initializer") {
-        quote!()
-    } else {
-        with_items.push(Ident::new("Initializer", Span::call_site()));
-        quote! {
-            impl ::rustpython_vm::types::Initializer for #self_ty {
-                type Args = ::rustpython_vm::function::FuncArgs;
-
-                fn slot_init(
-                    zelf: ::rustpython_vm::PyObjectRef,
-                    args: ::rustpython_vm::function::FuncArgs,
-                    vm: &::rustpython_vm::VirtualMachine,
-                ) -> ::rustpython_vm::PyResult<()> {
-                    <Self as ::rustpython_vm::class::PyClassDef>::Base::slot_init(zelf, args, vm)
-                }
-
-                fn init(
-                    _zelf: ::rustpython_vm::PyRef<Self>,
-                    _args: Self::Args,
-                    _vm: &::rustpython_vm::VirtualMachine
-                ) -> ::rustpython_vm::PyResult<()> {
-                    unreachable!("slot_init is defined")
-                }
-            }
-        }
-    };
+    // SimpleExtendsException: inherits BaseException_init from the base class via MRO.
+    // Only exceptions that explicitly specify `with(Initializer)` will have
+    // their own __init__ in __dict__.
+    let slot_init = quote!();
 
     let extra_attrs_tokens = if extra_attrs.is_empty() {
         quote!()
 
@@ -11,7 +11,7 @@ pub mod _hashlib {
         class::StaticType,
         convert::ToPyObject,
         function::{ArgBytesLike, ArgStrOrBytesLike, FuncArgs, OptionalArg},
-        types::{Constructor, Initializer, Representable},
+        types::{Constructor, Representable},
     };
     use blake2::{Blake2b512, Blake2s256};
     use digest::{DynDigest, core_api::BlockSizeUser};
 
@@ -7,7 +7,7 @@ pub(crate) mod ssl_error {
     use crate::vm::{
         Py, PyPayload, PyRef, PyResult, VirtualMachine,
         builtins::{PyBaseException, PyOSError, PyStrRef},
-        types::{Constructor, Initializer},
+        types::Constructor,
     };
 
     // Error type constants - exposed as pyattr and available for internal use
 
@@ -348,8 +348,18 @@ pub(super) mod types {
     impl Initializer for PyBaseExceptionGroup {
         type Args = FuncArgs;
 
-        fn slot_init(_zelf: PyObjectRef, _args: FuncArgs, _vm: &VirtualMachine) -> PyResult<()> {
-            // No-op: __new__ already set up the correct args (message, exceptions_tuple)
+        fn slot_init(zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
+            // BaseExceptionGroup_init: no kwargs allowed
+            if !args.kwargs.is_empty() {
+                return Err(vm.new_type_error(format!(
+                    "{} does not take keyword arguments",
+                    zelf.class().name()
+                )));
+            }
+            // Do NOT call PyBaseException::slot_init here.
+            // slot_new already set args to (message, exceptions_tuple).
+            // Calling base init would overwrite with original args (message, exceptions_list).
+            let _ = (zelf, args, vm);
             Ok(())
         }
 
 
@@ -1086,15 +1086,16 @@ fn syntax_error_set_msg(
 }
 
 fn system_exit_code(exc: PyBaseExceptionRef) -> Option<PyObjectRef> {
-    exc.args.read().first().map(|code| {
-        match_class!(match code {
-            ref tup @ PyTuple => match tup.as_slice() {
-                [x] => x.clone(),
-                _ => code.clone(),
-            },
-            other => other.clone(),
-        })
-    })
+    // SystemExit.code based on args length:
+    // - size == 0: code is None
+    // - size == 1: code is args[0]
+    // - size > 1: code is args (the whole tuple)
+    let args = exc.args.read();
+    match args.len() {
+        0 => None,
+        1 => Some(args.first().unwrap().clone()),
+        _ => Some(args.as_object().to_owned()),
+    }
 }
 
 #[cfg(feature = "serde")]
@@ -1255,7 +1256,7 @@ pub(super) mod types {
         },
         convert::ToPyObject,
         convert::ToPyResult,
-        function::{ArgBytesLike, FuncArgs},
+        function::{ArgBytesLike, FuncArgs, KwArgs},
         types::{Constructor, Initializer},
     };
     use crossbeam_utils::atomic::AtomicCell;
@@ -1393,11 +1394,29 @@ pub(super) mod types {
         pub(super) args: PyRwLock<PyTupleRef>,
     }
 
-    #[pyexception(name, base = PyBaseException, ctx = "system_exit", impl)]
+    #[pyexception(name, base = PyBaseException, ctx = "system_exit")]
     #[derive(Debug)]
     #[repr(transparent)]
     pub struct PySystemExit(PyBaseException);
 
+    // SystemExit_init: has its own __init__ that sets the code attribute
+    #[pyexception(with(Initializer))]
+    impl PySystemExit {}
+
+    impl Initializer for PySystemExit {
+        type Args = FuncArgs;
+        fn slot_init(zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
+            // Call BaseException_init first (handles args)
+            PyBaseException::slot_init(zelf, args, vm)
+            // Note: code is computed dynamically via system_exit_code getter
+            // so we don't need to set it here explicitly
+        }
+
+        fn init(_zelf: PyRef<Self>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<()> {
+            unreachable!("slot_init is defined")
+        }
+    }
+
     #[pyexception(name, base = PyBaseException, ctx = "generator_exit", impl)]
     #[derive(Debug)]
     #[repr(transparent)]
@@ -1474,16 +1493,25 @@ pub(super) mod types {
         type Args = FuncArgs;
 
         fn slot_init(zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
-            zelf.set_attr(
-                "name",
-                vm.unwrap_or_none(args.kwargs.get("name").cloned()),
-                vm,
-            )?;
-            zelf.set_attr(
-                "obj",
-                vm.unwrap_or_none(args.kwargs.get("obj").cloned()),
-                vm,
-            )?;
+            // Only 'name' and 'obj' kwargs are allowed
+            let mut kwargs = args.kwargs.clone();
+            let name = kwargs.swap_remove("name");
+            let obj = kwargs.swap_remove("obj");
+
+            // Reject unknown kwargs
+            if let Some(invalid_key) = kwargs.keys().next() {
+                return Err(vm.new_type_error(format!(
+                    "AttributeError() got an unexpected keyword argument '{invalid_key}'"
+                )));
+            }
+
+            // Pass args without kwargs to BaseException_init
+            let base_args = FuncArgs::new(args.args.clone(), KwArgs::default());
+            PyBaseException::slot_init(zelf.clone(), base_args, vm)?;
+
+            // Set attributes
+            zelf.set_attr("name", vm.unwrap_or_none(name), vm)?;
+            zelf.set_attr("obj", vm.unwrap_or_none(obj), vm)?;
             Ok(())
         }
 
@@ -1529,9 +1557,11 @@ pub(super) mod types {
         type Args = FuncArgs;
 
         fn slot_init(zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
+            // Only 'name', 'path', 'name_from' kwargs are allowed
             let mut kwargs = args.kwargs.clone();
             let name = kwargs.swap_remove("name");
             let path = kwargs.swap_remove("path");
+            let name_from = kwargs.swap_remove("name_from");
 
             // Check for any remaining invalid keyword arguments
             if let Some(invalid_key) = kwargs.keys().next() {
@@ -1543,6 +1573,7 @@ pub(super) mod types {
             let dict = zelf.dict().unwrap();
             dict.set_item("name", vm.unwrap_or_none(name), vm)?;
             dict.set_item("path", vm.unwrap_or_none(path), vm)?;
+            dict.set_item("name_from", vm.unwrap_or_none(name_from), vm)?;
             PyBaseException::slot_init(zelf, args, vm)
         }
 
@@ -1592,11 +1623,45 @@ pub(super) mod types {
     #[repr(transparent)]
     pub struct PyMemoryError(PyException);
 
-    #[pyexception(name, base = PyException, ctx = "name_error", impl)]
+    #[pyexception(name, base = PyException, ctx = "name_error")]
     #[derive(Debug)]
     #[repr(transparent)]
     pub struct PyNameError(PyException);
 
+    // NameError_init: handles the .name. kwarg
+    #[pyexception(with(Initializer))]
+    impl PyNameError {}
+
+    impl Initializer for PyNameError {
+        type Args = FuncArgs;
+        fn slot_init(zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
+            // Only 'name' kwarg is allowed
+            let mut kwargs = args.kwargs.clone();
+            let name = kwargs.swap_remove("name");
+
+            // Reject unknown kwargs
+            if let Some(invalid_key) = kwargs.keys().next() {
+                return Err(vm.new_type_error(format!(
+                    "NameError() got an unexpected keyword argument '{invalid_key}'"
+                )));
+            }
+
+            // Pass args without kwargs to BaseException_init
+            let base_args = FuncArgs::new(args.args.clone(), KwArgs::default());
+            PyBaseException::slot_init(zelf.clone(), base_args, vm)?;
+
+            // Set name attribute if provided
+            if let Some(name) = name {
+                zelf.set_attr("name", name, vm)?;
+            }
+            Ok(())
+        }
+
+        fn init(_zelf: PyRef<Self>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<()> {
+            unreachable!("slot_init is defined")
+        }
+    }
+
     #[pyexception(name, base = PyNameError, ctx = "unbound_local_error", impl)]
     #[derive(Debug)]
     #[repr(transparent)]
@@ -2232,31 +2297,17 @@ pub(super) mod types {
         }
     }
 
+    // MiddlingExtendsException: inherits __init__ from SyntaxError via MRO
     #[pyexception(
         name = "_IncompleteInputError",
         base = PySyntaxError,
-        ctx = "incomplete_input_error"
+        ctx = "incomplete_input_error",
+        impl
     )]
     #[derive(Debug)]
     #[repr(transparent)]
     pub struct PyIncompleteInputError(PySyntaxError);
 
-    #[pyexception(with(Initializer))]
-    impl PyIncompleteInputError {}
-
-    impl Initializer for PyIncompleteInputError {
-        type Args = FuncArgs;
-
-        fn slot_init(zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
-            zelf.set_attr("name", vm.ctx.new_str("SyntaxError"), vm)?;
-            PySyntaxError::slot_init(zelf, args, vm)
-        }
-
-        fn init(_zelf: PyRef<Self>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<()> {
-            unreachable!("slot_init is defined")
-        }
-    }
-
     #[pyexception(name, base = PySyntaxError, ctx = "indentation_error", impl)]
     #[derive(Debug)]
     #[repr(transparent)]
 
@@ -239,12 +239,10 @@ class SubError(MyError):
     raise e
 except MyError as exc:
     # It was a segmentation fault before, will print info to stdout:
-    if platform.python_implementation() == "RustPython":
-        # For some reason `CPython` hangs on this code:
-        sys.excepthook(type(exc), exc, exc.__traceback__)
-        assert isinstance(exc, MyError)
-        assert exc.__cause__ is None
-        assert exc.__context__ is e
+    sys.excepthook(type(exc), exc, exc.__traceback__)
+    assert isinstance(exc, MyError)
+    assert exc.__cause__ is None
+    assert exc.__context__ is e
 
 
 # Regression to
@@ -255,26 +253,42 @@ class SubError(MyError):
 assert BaseException.__init__.__qualname__ == "BaseException.__init__"
 assert BaseException().__dict__ == {}
 
+# Exception inherits __init__ from BaseException
 assert Exception.__new__.__qualname__ == "Exception.__new__", (
     Exception.__new__.__qualname__
 )
-assert Exception.__init__.__qualname__ == "Exception.__init__", (
+assert Exception.__init__.__qualname__ == "BaseException.__init__", (
     Exception.__init__.__qualname__
 )
 assert Exception().__dict__ == {}
 
 
-# Extends `BaseException`, simple:
+# Extends `BaseException`, simple - inherits __init__ from BaseException:
 assert KeyboardInterrupt.__new__.__qualname__ == "KeyboardInterrupt.__new__", (
     KeyboardInterrupt.__new__.__qualname__
 )
-assert KeyboardInterrupt.__init__.__qualname__ == "KeyboardInterrupt.__init__"
+assert KeyboardInterrupt.__init__.__qualname__ == "BaseException.__init__"
 assert KeyboardInterrupt().__dict__ == {}
 
 
-# Extends `Exception`, simple:
+# Extends `BaseException`, complex - has its own __init__:
+# SystemExit_init sets self.code based on args length
+assert SystemExit.__init__.__qualname__ == "SystemExit.__init__"
+assert SystemExit.__dict__.get("__init__") is not None, (
+    "SystemExit must have its own __init__"
+)
+assert SystemExit.__init__ is not BaseException.__init__
+assert SystemExit().__dict__ == {}
+# SystemExit.code behavior:
+assert SystemExit().code is None
+assert SystemExit(1).code == 1
+assert SystemExit(1, 2).code == (1, 2)
+assert SystemExit(1, 2, 3).code == (1, 2, 3)
+
+
+# Extends `Exception`, simple - inherits __init__ from BaseException:
 assert TypeError.__new__.__qualname__ == "TypeError.__new__"
-assert TypeError.__init__.__qualname__ == "TypeError.__init__"
+assert TypeError.__init__.__qualname__ == "BaseException.__init__"
 assert TypeError().__dict__ == {}
 
 
@@ -356,7 +370,8 @@ class SubError(MyError):
 # Custom `__new__` and `__init__`:
 assert ImportError.__init__.__qualname__ == "ImportError.__init__"
 assert ImportError(name="a").name == "a"
-assert ModuleNotFoundError.__init__.__qualname__ == "ModuleNotFoundError.__init__"
+# ModuleNotFoundError inherits __init__ from ImportError via MRO (MiddlingExtendsException)
+assert ModuleNotFoundError.__init__.__qualname__ == "ImportError.__init__"
 assert ModuleNotFoundError(name="a").name == "a"