check surrogates

youknowone · youknowone · commit 44577697efdf · 2025-12-27T11:05:49.000+09:00
diff --git a/Lib/test/test_builtin.py b/Lib/test/test_builtin.py
@@ -2401,8 +2401,6 @@ def test_type_nokwargs(self):
         with self.assertRaises(TypeError):
             type('a', (), dict={})
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_type_name(self):
         for name in 'A', '\xc4', '\U0001f40d', 'B.A', '42', '':
             with self.subTest(name=name):
@@ -2452,8 +2450,6 @@ def test_type_qualname(self):
             A.__qualname__ = b'B'
         self.assertEqual(A.__qualname__, 'D.E')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_type_doc(self):
         for doc in 'x', '\xc4', '\U0001f40d', 'x\x00y', b'x', 42, None:
             A = type('A', (), {'__doc__': doc})
diff --git a/crates/vm/src/builtins/str.rs b/crates/vm/src/builtins/str.rs
@@ -441,7 +441,7 @@ impl PyStr {
         self.data.as_str()
     }
 
-    fn ensure_valid_utf8(&self, vm: &VirtualMachine) -> PyResult<()> {
+    pub(crate) fn ensure_valid_utf8(&self, vm: &VirtualMachine) -> PyResult<()> {
         if self.is_utf8() {
             Ok(())
         } else {
diff --git a/crates/vm/src/builtins/type.rs b/crates/vm/src/builtins/type.rs
@@ -1163,6 +1163,7 @@ impl PyType {
         if name.as_bytes().contains(&0) {
             return Err(vm.new_value_error("type name must not contain null characters"));
         }
+        name.ensure_valid_utf8(vm)?;
 
         // Use std::mem::replace to swap the new value in and get the old value out,
         // then drop the old value after releasing the lock (similar to CPython's Py_SETREF)
@@ -1254,6 +1255,7 @@ impl Constructor for PyType {
         if name.as_bytes().contains(&0) {
             return Err(vm.new_value_error("type name must not contain null characters"));
         }
+        name.ensure_valid_utf8(vm)?;
 
         let (metatype, base, bases, base_is_type) = if bases.is_empty() {
             let base = vm.ctx.types.object_type.to_owned();
@@ -1306,6 +1308,13 @@ impl Constructor for PyType {
             });
         let mut attributes = dict.to_attributes(vm);
 
+        // Check __doc__ for surrogates - raises UnicodeEncodeError during type creation
+        if let Some(doc) = attributes.get(identifier!(vm, __doc__))
+            && let Some(doc_str) = doc.downcast_ref::<PyStr>()
+        {
+            doc_str.ensure_valid_utf8(vm)?;
+        }
+
         if let Some(f) = attributes.get_mut(identifier!(vm, __init_subclass__))
             && f.class().is(vm.ctx.types.function_type)
         {
@@ -1340,6 +1349,13 @@ impl Constructor for PyType {
 
         let (heaptype_slots, add_dict): (Option<PyRef<PyTuple<PyStrRef>>>, bool) =
             if let Some(x) = attributes.get(identifier!(vm, __slots__)) {
+                // Check if __slots__ is bytes - not allowed
+                if x.class().is(vm.ctx.types.bytes_type) {
+                    return Err(vm.new_type_error(
+                        "__slots__ items must be strings, not 'bytes'".to_owned(),
+                    ));
+                }
+
                 let slots = if x.class().is(vm.ctx.types.str_type) {
                     let x = unsafe { x.downcast_unchecked_ref::<PyStr>() };
                     PyTuple::new_ref_typed(vec![x.to_owned()], &vm.ctx)
@@ -1348,6 +1364,12 @@ impl Constructor for PyType {
                     let elements = {
                         let mut elements = Vec::new();
                         while let PyIterReturn::Return(element) = iter.next(vm)? {
+                            // Check if any slot item is bytes
+                            if element.class().is(vm.ctx.types.bytes_type) {
+                                return Err(vm.new_type_error(
+                                    "__slots__ items must be strings, not 'bytes'".to_owned(),
+                                ));
+                            }
                             elements.push(element);
                         }
                         elements

Original file line number	Diff line number	Diff line change
`@@ -441,7 +441,7 @@ impl PyStr {`
`441`	`441`	`self.data.as_str()`
`442`	`442`	`}`
`443`	`443`
`444`		`- fn ensure_valid_utf8(&self, vm: &VirtualMachine) -> PyResult<()> {`
	`444`	`+ pub(crate) fn ensure_valid_utf8(&self, vm: &VirtualMachine) -> PyResult<()> {`
`445`	`445`	`if self.is_utf8() {`
`446`	`446`	`Ok(())`
`447`	`447`	`} else {`