wip

youknowone · youknowone · commit 3574d2cbabe6 · 2025-06-28T12:51:16.000+09:00
diff --git a/vm/src/builtins/type.rs b/vm/src/builtins/type.rs
@@ -972,26 +972,38 @@ impl Constructor for PyType {
         if let Some(ref slots) = heaptype_slots {
             let mut offset = base_member_count;
             for member in slots.as_slice() {
-                let member_def = PyMemberDef {
-                    name: member.to_string(),
-                    kind: MemberKind::ObjectEx,
-                    getter: MemberGetter::Offset(offset),
-                    setter: MemberSetter::Offset(offset),
-                    doc: None,
-                };
-                let member_descriptor: PyRef<PyMemberDescriptor> =
-                    vm.ctx.new_pyref(PyMemberDescriptor {
-                        common: PyDescriptorOwned {
-                            typ: typ.clone(),
-                            name: vm.ctx.intern_str(member.as_str()),
-                            qualname: PyRwLock::new(None),
-                        },
-                        member: member_def,
-                    });
-
                 let attr_name = vm.ctx.intern_str(member.to_string());
-                if !typ.has_attr(attr_name) {
-                    typ.set_attr(attr_name, member_descriptor.into());
+
+                // Special handling for __dict__ slot - use getset_descriptor instead of member_descriptor
+                if member.as_str() == "__dict__" {
+                    if !typ.has_attr(attr_name) {
+                        let dict_descriptor = unsafe {
+                            vm.ctx
+                                .new_getset("__dict__", &typ, subtype_get_dict, subtype_set_dict)
+                        };
+                        typ.set_attr(attr_name, dict_descriptor.into());
+                    }
+                } else {
+                    let member_def = PyMemberDef {
+                        name: member.to_string(),
+                        kind: MemberKind::ObjectEx,
+                        getter: MemberGetter::Offset(offset),
+                        setter: MemberSetter::Offset(offset),
+                        doc: None,
+                    };
+                    let member_descriptor: PyRef<PyMemberDescriptor> =
+                        vm.ctx.new_pyref(PyMemberDescriptor {
+                            common: PyDescriptorOwned {
+                                typ: typ.clone(),
+                                name: vm.ctx.intern_str(member.as_str()),
+                                qualname: PyRwLock::new(None),
+                            },
+                            member: member_def,
+                        });
+
+                    if !typ.has_attr(attr_name) {
+                        typ.set_attr(attr_name, member_descriptor.into());
+                    }
                 }
 
                 offset += 1;
@@ -1005,13 +1017,34 @@ impl Constructor for PyType {
             // (with exceptions, e.g function)
             // Also, type subclasses don't need their own __dict__ descriptor
             // since they inherit it from type
-            if !inherits_from_type {
+            // Additionally, if __slots__ contains __dict__, don't add descriptor
+            // as the slot handles __dict__ directly
+            let has_dict_slot = attributes
+                .get(identifier!(vm, __slots__))
+                .and_then(|slots| {
+                    if let Ok(tuple) = slots.clone().downcast::<PyTuple>() {
+                        Some(tuple.iter().any(|item| {
+                            item.downcast_ref::<PyStr>()
+                                .map(|s| s.as_str() == "__dict__")
+                                .unwrap_or(false)
+                        }))
+                    } else if let Ok(string) = slots.clone().downcast::<PyStr>() {
+                        Some(string.as_str() == "__dict__")
+                    } else {
+                        None
+                    }
+                })
+                .unwrap_or(false);
+
+            if !inherits_from_type && !has_dict_slot {
                 let __dict__ = identifier!(vm, __dict__);
-                attributes.entry(__dict__).or_insert_with(|| unsafe {
-                    vm.ctx
-                        .new_getset("__dict__", &typ, subtype_get_dict, subtype_set_dict)
-                        .into()
-                });
+                if !attributes.contains_key(__dict__) {
+                    attributes.insert(__dict__, unsafe {
+                        vm.ctx
+                            .new_getset("__dict__", &typ, subtype_get_dict, subtype_set_dict)
+                            .into()
+                    });
+                }
             }
 
             if let Some(cell) = attributes.get(identifier!(vm, __classcell__)) {
