// Check if base has itemsize > 0 - can't add arbitrary slots to variable-size types

// Types like int, bytes, tuple have itemsize > 0 and don't allow custom slots

// But types like weakref.ref have itemsize = 0 and DO allow slots

let has_custom_slots = slots

.iter()

.any(|s| s.as_str() != "__dict__" && s.as_str() != "__weakref__");

if has_custom_slots && base.slots.itemsize > 0 {

return Err(vm.new_type_error(format!(

"nonempty __slots__ not supported for subtype of '{}'",

base.name()

)));

}

// Validate slot names and track duplicates

let mut seen_dict = false;

let mut seen_weakref = false;

// Use isidentifier for validation (handles Unicode properly)

let slot_name = slot.as_str();

// Check for duplicate __dict__

if slot_name == "__dict__" {

if seen_dict {

return Err(vm.new_type_error(

"__dict__ slot disallowed: we already got one".to_owned(),

));

}

seen_dict = true;

}

// Check for duplicate __weakref__

if slot_name == "__weakref__" {

if seen_weakref {

return Err(vm.new_type_error(

"__weakref__ slot disallowed: we already got one".to_owned(),

));

}

seen_weakref = true;

}

// Check if slot name conflicts with class attributes

if attributes.contains_key(vm.ctx.intern_str(slot_name)) {

return Err(vm.new_value_error(format!(

"'{}' in __slots__ conflicts with a class variable",

slot_name

)));

}

}

// Check if base class already has __dict__ - can't redefine it

if seen_dict && base.slots.flags.has_feature(PyTypeFlags::HAS_DICT) {

return Err(

vm.new_type_error("__dict__ slot disallowed: we already got one".to_owned())

);

}

// Check if base class already has __weakref__ - can't redefine it

// A base has weakref support if:

// 1. It's a heap type without explicit __slots__ (automatic weakref), OR

// 2. It's a heap type with __weakref__ in its __slots__

if seen_weakref {

let base_has_weakref = if let Some(ref ext) = base.heaptype_ext {

match &ext.slots {

// Heap type without __slots__ - has automatic weakref

None => true,

// Heap type with __slots__ - check if __weakref__ is in slots

Some(base_slots) => base_slots.iter().any(|s| s.as_str() == "__weakref__"),

}

} else {

// Builtin type - check if it has __weakref__ descriptor

let weakref_name = vm.ctx.intern_str("__weakref__");

base.attributes.read().contains_key(weakref_name)

};

if base_has_weakref {

return Err(vm.new_type_error(

"__weakref__ slot disallowed: we already got one".to_owned(),

));

}