crates/vm/src/vm/vm_new.rs (1)

357-369: 📐 Maintainability & Code Quality | 🔵 Trivial | ⚡ Quick win

Add a debug-mode type/class consistency guard.

new_payload_exception builds a PyRef<T> from an arbitrary cls: PyTypeRef argument. The function relies only on the doc comment to state that T must match the exact built-in type. new_exception in this same file guards this exact class of misuse with a debug_assert_eq! on basicsize. Add a similar guard here.

Do this before merging the payload into into_ref_with_type_lazy_dict. Compare cls.slots.basicsize against core::mem::size_of::<T>() in a debug_assert_eq!, with a message that points callers to the doc comment.

♻️ Proposed defensive guard

     pub fn new_payload_exception<T>(&self, cls: PyTypeRef, args: FuncArgs) -> PyResult<PyRef<T>>
     where
         T: Constructor<Args = FuncArgs> + Initializer,
     {
+        debug_assert_eq!(
+            cls.slots.basicsize,
+            core::mem::size_of::<T>(),
+            "vm.new_payload_exception::<{}>() called with mismatched type '{}'",
+            core::any::type_name::<T>(),
+            cls.name()
+        );
         let payload = T::py_new(&cls, args.clone(), self)?;
         let exc = payload.into_ref_with_type_lazy_dict(self, cls)?;
         T::slot_init(exc.as_object().to_owned(), args, self)?;
         Ok(exc)
     }

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@crates/vm/src/vm/vm_new.rs` around lines 357 - 369, Add a debug_assert_eq! in
new_payload_exception immediately before into_ref_with_type_lazy_dict, comparing
cls.slots.basicsize with core::mem::size_of::<T>() and including a message
directing callers to the doc comment.

crates/vm/src/stdlib/sys.rs (1)

779-783: 📐 Maintainability & Code Quality | 🔵 Trivial | ⚡ Quick win

Duplicate SystemExit construction across four files. Each site builds SystemExit through the identical sequence new_payload_exception::<PySystemExit>(vm.ctx.exceptions.system_exit.to_owned(), <args>)?.upcast(), differing only in the args value. Extract one shared helper instead of repeating the construction logic.

• crates/vm/src/stdlib/sys.rs#L779-L783: replace the inline construction with a call to a new vm.new_system_exit(args.into()) helper.
• crates/vm/src/stdlib/_thread.rs#L638-L643: replace the inline construction with vm.new_system_exit(vec![].into()).
• crates/vm/src/stdlib/builtins.rs#L1044-L1049: replace the inline construction with vm.new_system_exit(vec![code].into()).
• crates/vm/src/vm/mod.rs#L2172-L2177: replace the inline construction with self.new_system_exit(vec![].into()).

Add the helper to crates/vm/src/vm/vm_new.rs, next to new_stop_iteration:

pub fn new_system_exit(&self, args: FuncArgs) -> PyBaseExceptionRef {
    self.new_payload_exception::<PySystemExit>(
        self.ctx.exceptions.system_exit.to_owned(),
        args,
    )
    .expect("SystemExit is a BaseException Subclass.")
    .upcast()
}

As per coding guidelines, "When branches differ only in a value but share logic, extract the differing value and invoke the common logic once."

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@crates/vm/src/stdlib/sys.rs` around lines 779 - 783, Extract the repeated
SystemExit construction into new_system_exit in crates/vm/src/vm/vm_new.rs
beside new_stop_iteration, accepting FuncArgs and returning PyBaseExceptionRef
with the existing payload-exception behavior. Replace the inline construction at
crates/vm/src/stdlib/sys.rs:779-783 with vm.new_system_exit(args.into()), at
crates/vm/src/stdlib/_thread.rs:638-643 with vm.new_system_exit(vec![].into()),
at crates/vm/src/stdlib/builtins.rs:1044-1049 with
vm.new_system_exit(vec![code].into()), and at crates/vm/src/vm/mod.rs:2172-2177
with self.new_system_exit(vec![].into()).

Source: Coding guidelines