vm/src/protocol/object.rs (1)

645-649: Nit: clarify the rationale in the comment and add a regression test for subclass override.

The comment is correct but a bit terse. Suggest expanding it to capture why the fast-path is safe and how subclass semantics are preserved. Also, it would be good to add tests that: (1) a str subclass with a custom hash still uses the override, and (2) assigning to str.hash raises TypeError.

Apply this small comment tweak:

-        // __hash__ function in str cannot be overwritten
+        // Fast-path: for exact str objects we can bypass attribute lookup/MRO walk and
+        // call PyStr::hash directly. The builtin str type is a static (immutable) type,
+        // so str.__hash__ is not settable; restricting to exact PyStr preserves subclass
+        // semantics (overrides on str subclasses still apply).

Example tests to consider adding:

# tests/test_str_hash_fastpath.py
import unittest

class MyStr(str):
    def __hash__(self):
        return 42

class TestStrHashFastPath(unittest.TestCase):
    def test_exact_str_fast_path_semantics(self):
        s = "abc"
        self.assertEqual(hash(s), hash("abc"))  # stable equality
        # sanity: repeated calls equal
        self.assertEqual(hash(s), hash(s))

    def test_subclass_override_is_respected(self):
        t = MyStr("abc")
        self.assertEqual(hash(t), 42)

    def test_cannot_assign_str_hash(self):
        with self.assertRaises(TypeError):
            str.__hash__ = lambda self: 0

Configuration used: .coderabbit.yml
Review profile: CHILL
Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

vm/src/protocol/object.rs (1)

645-652: Optional: add exact PyStr fast path and check the immediate class slot before walking the MRO.

• Exact PyStr cannot override hash, so an early downcast avoids any MRO walk or slot fetch.
• Checking the immediate class slot first avoids scanning the full MRO for the common case where the class itself defines the hash slot.
• Use new_type_error for consistency with the rest of this file.

Apply this diff:

-        if let Some(hash) = self.class().mro_find_map(|cls| cls.slots.hash.load()) {
-            return hash(self, vm);
-        }
+        // Fast path 1: exact built-in str — cannot override __hash__, so we can
+        // bypass MRO/descriptor lookups entirely.
+        if let Ok(s) = self.to_owned().downcast_exact::<PyStr>(vm) {
+            return PyStr::hash(&s, vm);
+        }
+        // Fast path 2: check the immediate class slot before walking the MRO.
+        let cls = self.class();
+        if let Some(hash) = cls.slots.hash.load() {
+            return hash(self, vm);
+        }
+        // Fallback: search along the MRO (RustPython doesn't inherit slots yet).
+        if let Some(hash) = cls.mro_find_map(|cls| cls.slots.hash.load()) {
+            return hash(self, vm);
+        }
 
-        return Err(vm.new_exception_msg(
-            vm.ctx.exceptions.type_error.to_owned(),
-            format!("unhashable type: '{}'", self.class().name()),
-        ));
+        return Err(vm.new_type_error(format!(
+            "unhashable type: '{}'",
+            self.class().name()
+        )));

Configuration used: .coderabbit.yml
Review profile: CHILL
Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.