⚠️ Potential issue | 🟠 Major

Fragile error detection heuristic with potential issues.

The debug diagnostic logic has several concerns:

1. Line 846: err.as_object().repr(vm)? can fail, which would replace the original error with a repr failure error, masking the actual problem.

2. Line 848: Counting class name occurrences in the error message is fragile and depends on exact error message formatting. This heuristic could produce false positives or miss legitimate cases if error message formats change.

3. Lines 850-853: Using panic! in error handling is unconventional. In debug builds, this immediately crashes rather than allowing normal error propagation, which could complicate debugging in some scenarios.

Consider these alternatives:

• Use a more robust detection method (e.g., error type checking rather than message parsing)
• Log a warning instead of panicking to preserve normal error flow
• Handle the repr() failure gracefully to avoid masking the original error

Apply this diff to handle repr() failure safely:

         #[cfg(debug_assertions)]
         {
-            let msg = err.as_object().repr(vm)?;
+            if let Ok(msg) = err.as_object().repr(vm) {
-            let double_appearance =
-                msg.as_str().matches(&class_name_for_debug as &str).count() == 2;
-            if double_appearance {
-                panic!(
-                    "This type `{}` doesn't seem to support `init`. Override `slot_init` instead: {}",
-                    class_name_for_debug, msg
-                );
+                let double_appearance =
+                    msg.as_str().matches(&class_name_for_debug as &str).count() == 2;
+                if double_appearance {
+                    panic!(
+                        "This type `{}` doesn't seem to support `init`. Override `slot_init` instead: {}",
+                        class_name_for_debug, msg
+                    );
+                }
             }
         }

crates/vm/src/types/slot.rs around lines 838 to 858: the debug diagnostic
currently calls err.as_object().repr(vm)? (which can fail and mask the original
error), uses fragile string-occurrence heuristics to detect the class-name, and
panics on detection; change this to first try to inspect the error in a
non-fallible way (prefer checking the error type via downcast/pattern-match or a
stable error variant rather than parsing repr), if you must render repr() call
wrap it in a safe fallible path (e.g., match or map_err) so a repr failure is
ignored/logged and the original err is preserved, replace panic! with a
non-aborting diagnostic (log::warn! or vm logger) that includes any
safely-obtained context, and always return Err(err) so normal error propagation
is preserved.

@coderabbitai please apply it for me

@youknowone, I'll provide the complete fixed version of the slot_init function. Here's the updated code with the safer error handling:

#[pyslot]
#[inline]
fn slot_init(zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
    #[cfg(debug_assertions)]
    let class_name_for_debug = zelf.class().name().to_string();

    let zelf = match zelf.try_into_value(vm) {
        Ok(zelf) => zelf,
        Err(err) => {
            #[cfg(debug_assertions)]
            {
                if let Ok(msg) = err.as_object().repr(vm) {
                    let double_appearance =
                        msg.as_str().matches(&class_name_for_debug as &str).count() == 2;
                    if double_appearance {
                        panic!(
                            "This type `{}` doesn't seem to support `init`. Override `slot_init` instead: {}",
                            class_name_for_debug, msg
                        );
                    }
                }
            }
            return Err(err);
        }
    };
    let args: Self::Args = args.bind(vm)?;
    Self::init(zelf, args, vm)
}

What changed:

• Wrapped err.as_object().repr(vm)? with if let Ok(msg) = err.as_object().repr(vm)
• This prevents the repr() call from failing and masking the original error
• If repr() fails, the diagnostic is simply skipped and the original error is returned
• The indentation of the subsequent lines is adjusted to be inside the if let block

This makes the debug diagnostic more robust and ensures the original error is always preserved.