Fix object.__init__ excess-arg checks for heap types

moreal · moreal · commit 3538304387da · 2026-02-14T00:16:19.000+09:00
diff --git a/Lib/test/test_class.py b/Lib/test/test_class.py
@@ -741,7 +741,6 @@ def __setattr__(self, name, value) -> None:
         with self.assertRaisesRegex(AttributeError, error_msg):
             del B().z
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def testConstructorErrorMessages(self):
         # bpo-31506: Improves the error message logic for object_new & object_init
 
diff --git a/Lib/test/test_descr.py b/Lib/test/test_descr.py
@@ -1853,7 +1853,6 @@ class C(list):
             __new__ = object.__new__
         self.assertRaises(TypeError, C)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_object_new(self):
         class A(object):
             pass
diff --git a/crates/vm/src/builtins/object.rs b/crates/vm/src/builtins/object.rs
@@ -127,26 +127,29 @@ impl Initializer for PyBaseObject {
         let typ = zelf.class();
         let object_type = &vm.ctx.types.object_type;
 
-        let typ_init = typ.slots.init.load().map(|f| f as usize);
-        let object_init = object_type.slots.init.load().map(|f| f as usize);
-
-        // if (type->tp_init != object_init) → first error
-        if typ_init != object_init {
-            return Err(vm.new_type_error(
-                "object.__init__() takes exactly one argument (the instance to initialize)"
-                    .to_owned(),
-            ));
-        }
-
-        let typ_new = typ.slots.new.load().map(|f| f as usize);
-        let object_new = object_type.slots.new.load().map(|f| f as usize);
+        if let (Some(typ_init), Some(object_init)) = (
+            typ.get_attr(identifier!(vm, __init__)),
+            object_type.get_attr(identifier!(vm, __init__)),
+        ) {
+            // if (type->tp_init != object_init) → first error
+            if !typ_init.is(&object_init) {
+                return Err(vm.new_type_error(
+                    "object.__init__() takes exactly one argument (the instance to initialize)"
+                        .to_owned(),
+                ));
+            }
 
-        // if (type->tp_new == object_new) → second error
-        if typ_new == object_new {
-            return Err(vm.new_type_error(format!(
-                "{}.__init__() takes exactly one argument (the instance to initialize)",
-                typ.name()
-            )));
+            // if (type->tp_new == object_new) → second error
+            if let (Some(typ_new), Some(object_new)) = (
+                typ.get_attr(identifier!(vm, __new__)),
+                object_type.get_attr(identifier!(vm, __new__)),
+            ) && typ_new.is(&object_new)
+            {
+                return Err(vm.new_type_error(format!(
+                    "{}.__init__() takes exactly one argument (the instance to initialize)",
+                    typ.name()
+                )));
+            }
         }
 
         // Both conditions false → OK (e.g., tuple, dict with custom __new__)
