youknowone · Nov 5, 2026 · Nov 4, 2026 · Nov 4, 2026 · coderabbitai · Nov 5, 2026
diff --git a/Lib/test/test_cmd_line_script.py b/Lib/test/test_cmd_line_script.py
@@ -551,7 +551,7 @@ def test_pep_409_verbiage(self):
             self.assertStartsWith(text[1], '  File ')
             self.assertStartsWith(text[3], 'NameError')
 
-    @unittest.expectedFailureIf(sys.platform in ("android", "linux"), "TODO: RUSTPYTHON")
+    @unittest.expectedFailureIf(sys.platform == "android", "TODO: RUSTPYTHON")
     def test_non_ascii(self):
         # Apple platforms deny the creation of a file with an invalid UTF-8 name.
         # Windows allows creating a name with an arbitrary bytes name, but

diff --git a/crates/stdlib/src/faulthandler.rs b/crates/stdlib/src/faulthandler.rs
@@ -64,17 +64,19 @@ mod decl {
     // _Py_DumpHexadecimal (traceback.c)
     #[cfg(any(unix, windows))]
     fn dump_hexadecimal(fd: i32, value: u64, width: usize) {
-        const HEX_CHARS: &[u8; 16] = b"0123456789abcdef";
-        let mut buf = [0u8; 18]; // "0x" + 16 hex digits
-        buf[0] = b'0';
-        buf[1] = b'x';
+        puts(fd, "0x");
+        dump_hex_digits(fd, value, width);
+    }
 
-        for i in 0..width {
+    #[cfg(any(unix, windows))]
+    fn dump_hex_digits(fd: i32, value: u64, width: usize) {
+        const HEX_CHARS: &[u8; 16] = b"0123456789abcdef";
+        let mut buf = [0u8; 16];
+        for (i, byte) in buf.iter_mut().take(width).enumerate() {
             let digit = ((value >> (4 * (width - 1 - i))) & 0xf) as usize;
-            buf[2 + i] = HEX_CHARS[digit];
+            *byte = HEX_CHARS[digit];
         }
-
-        puts_bytes(fd, &buf[..2 + width]);
+        puts_bytes(fd, &buf[..width]);
     }
 
     // _Py_DumpDecimal (traceback.c)
@@ -145,8 +147,8 @@ mod decl {
     #[cfg(any(unix, windows))]
     fn dump_iframe(fd: i32, iframe: &rustpython_vm::frame::InterpreterFrame) {
         let code = iframe.code();
-        let filename = code.source_path().as_str();
-        let funcname = code.obj_name.as_str();
+        let filename = code.source_path().as_wtf8();
+        let funcname = code.obj_name.as_wtf8();
         let lasti = iframe.get_lasti();
         let lineno = if lasti == 0 {
             code.first_line_number.map_or(1, |n| n.get()) as u32
@@ -193,27 +195,36 @@ mod decl {
     #[cfg(any(unix, windows))]
     const MAX_STRING_LENGTH: usize = 500;
 
-    /// Truncate a UTF-8 string to at most `max_bytes` without splitting a
-    /// multi-byte codepoint. Signal-safe (no allocation, no panic).
+    /// `_Py_DumpASCII`: escape non-printable code points and truncate by
+    /// character count, without allocation or Python calls in a signal handler.
     #[cfg(any(unix, windows))]
-    fn safe_truncate(s: &str, max_bytes: usize) -> (&str, bool) {
-        if s.len() <= max_bytes {
-            return (s, false);
+    fn dump_ascii(fd: i32, s: &rustpython_common::wtf8::Wtf8) {
+        let prefix = &s.as_bytes()[..s.len().min(MAX_STRING_LENGTH)];
+        if prefix.iter().all(|byte| (0x20..=0x7e).contains(byte)) {
+            puts_bytes(fd, prefix);
+            if s.len() > MAX_STRING_LENGTH {
+                puts(fd, "...");
+            }
+            return;
         }
-        let mut end = max_bytes;
-        while end > 0 && !s.is_char_boundary(end) {
-            end -= 1;
+        let mut points = s.code_points();
+        for point in points.by_ref().take(MAX_STRING_LENGTH) {
+            let value = point.to_u32();
+            if (0x20..=0x7e).contains(&value) {
+                puts_bytes(fd, &[value as u8]);
+            } else {
+                let (prefix, width) = if value <= 0xff {
+                    ("\\x", 2)
+                } else if value <= 0xffff {
+                    ("\\u", 4)
+                } else {
+                    ("\\U", 8)
+                };
+                puts(fd, prefix);
+                dump_hex_digits(fd, u64::from(value), width);
+            }
         }
-        (&s[..end], true)
-    }
-
-    /// Write a string to fd, truncating with "..." if it exceeds MAX_STRING_LENGTH.
-    /// Mirrors `_Py_DumpASCII` truncation behavior.
-    #[cfg(any(unix, windows))]
-    fn dump_ascii(fd: i32, s: &str) {
-        let (truncated_s, was_truncated) = safe_truncate(s, MAX_STRING_LENGTH);
-        puts(fd, truncated_s);
-        if was_truncated {
+        if points.next().is_some() {
             puts(fd, "...");
         }
     }

diff --git a/crates/vm/src/builtins/code.rs b/crates/vm/src/builtins/code.rs
@@ -26,6 +26,7 @@ use core::{
 };
 use malachite_bigint::BigInt;
 use num_traits::Zero;
+use rustpython_common::wtf8::Wtf8Buf;
 use rustpython_compiler_core::{OneIndexed, bytecode::CodeUnits, bytecode::PyCodeLocationInfoKind};
 
 /// State for iterating through code address ranges
@@ -860,13 +861,13 @@ fn frozen_co_filename(path: &str) -> Option<&'static str> {
 }
 
 fn apply_frozen_co_filename(code: &PyCode, vm: &VirtualMachine) {
-    let Some(new) = frozen_co_filename(code.source_path().as_str()) else {
+    let Some(new) = code.source_path().to_str().and_then(frozen_co_filename) else {
         return;
     };
     set_source_path_tree(code, vm.ctx.intern_str(new));
 }
 
-fn set_source_path_tree(code: &PyCode, interned: &'static PyStrInterned) {
+pub(crate) fn set_source_path_tree(code: &PyCode, interned: &'static PyStrInterned) {
     code.set_source_path(interned);
     for constant in code.constants.iter() {
         set_source_path_in_const(&constant.0, interned);
@@ -919,15 +920,19 @@ impl PyPayload for PyCode {
 
 impl Representable for PyCode {
     #[inline]
-    fn repr_str(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
+    fn repr_wtf8(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<Wtf8Buf> {
         let code = &zelf.code;
-        Ok(format!(
-            "<code object {} at {:#x}, file \"{}\", line {}>",
+        let mut repr = Wtf8Buf::from(format!(
+            "<code object {} at {:#x}, file \"",
             code.obj_name,
             zelf.get_id(),
-            zelf.source_path().as_str(),
+        ));
+        repr.push_wtf8(zelf.source_path().as_wtf8());
+        repr.push_str(&format!(
+            "\", line {}>",
             code.first_line_number.map_or(-1, |n| n.get() as i32)
-        ))
+        ));
+        Ok(repr)
     }
 }
 

diff --git a/crates/vm/src/builtins/traceback.rs b/crates/vm/src/builtins/traceback.rs
@@ -128,7 +128,7 @@ impl serde::Serialize for PyTraceback {
         struc.serialize_field("lineno", &self.lineno.get())?;
         struc.serialize_field(
             "filename",
-            self.frame.iframe().code().source_path().as_str(),
+            &self.frame.iframe().code().source_path().to_string_lossy(),
         )?;
         struc.end()
     }

diff --git a/crates/vm/src/exceptions.rs b/crates/vm/src/exceptions.rs
@@ -274,7 +274,7 @@ impl VirtualMachine {
 
         let traceback = exc.traceback.read().clone();
         if let Some(tb) = traceback {
-            write_traceback(output, &tb)?;
+            write_traceback(output, &tb, vm)?;
         }
 
         let varargs = exc.args();
@@ -510,7 +510,7 @@ impl VirtualMachine {
 #[cfg(feature = "host_env")]
 fn print_source_line<W: Write>(
     output: &mut W,
-    filename: &str,
+    filename: &std::path::Path,
     lineno: usize,
 ) -> Result<(), W::Error> {
     // TODO: use io.open() method instead, when available, according to https://github.com/python/cpython/blob/main/Python/traceback.c#L393
@@ -537,10 +537,11 @@ fn print_source_line<W: Write>(
 pub(crate) fn write_traceback<W: Write>(
     output: &mut W,
     traceback: &PyTracebackRef,
+    vm: &VirtualMachine,
 ) -> Result<(), W::Error> {
     writeln!(output, "Traceback (most recent call last):")?;
     for entry in traceback.iter() {
-        write_traceback_entry(output, &entry)?;
+        write_traceback_entry(output, &entry, vm)?;
     }
     Ok(())
 }
@@ -549,18 +550,34 @@ pub(crate) fn write_traceback<W: Write>(
 fn write_traceback_entry<W: Write>(
     output: &mut W,
     tb_entry: &Py<PyTraceback>,
+    vm: &VirtualMachine,
 ) -> Result<(), W::Error> {
-    let filename = tb_entry.frame.iframe().code().source_path().as_str();
+    let filename = tb_entry.frame.iframe().code().source_path();
+    // This fallback writer accepts UTF-8, unlike Python's traceback formatter.
+    // Escape lone surrogates as stderr's backslashreplace handler does, rather
+    // than replacing them or letting the interned-string UTF-8 accessor panic.
+    let mut display_filename = String::new();
+    for point in filename.as_wtf8().code_points() {
+        if let Some(ch) = point.to_char() {
+            display_filename.push(ch);
+        } else {
+            display_filename.push_str(&format!("\\u{:04x}", point.to_u32()));
+        }
+    }
     writeln!(
         output,
         r##"  File "{}", line {}, in {}"##,
-        filename.trim_start_matches(r"\\?\"),
+        display_filename.trim_start_matches(r"\\?\"),
         tb_entry.lineno,
         tb_entry.frame.iframe().code().obj_name
     )?;
 
     #[cfg(feature = "host_env")]
-    print_source_line(output, filename, tb_entry.lineno.get())?;
+    if let Ok(path) = vm.fsencode(filename) {
+        print_source_line(output, path.as_ref(), tb_entry.lineno.get())?;
+    }
+    #[cfg(not(feature = "host_env"))]
+    let _ = vm;
 
     Ok(())
 }

diff --git a/crates/vm/src/import.rs b/crates/vm/src/import.rs
@@ -384,14 +384,14 @@ fn remove_importlib_frames_inner(
         return (None, false);
     };
 
-    let file_name = traceback.frame.iframe().code().source_path().as_str();
+    let file_name = traceback.frame.iframe().code().source_path().as_bytes();
 
     let (inner_tb, mut now_in_importlib) =
         remove_importlib_frames_inner(vm, traceback.next.lock().clone(), always_trim);
-    if file_name == "<frozen importlib._bootstrap>"
-        || file_name == "<frozen importlib._bootstrap_external>"
-        || file_name == "_frozen_importlib"
-        || file_name == "_frozen_importlib_external"
+    if file_name == b"<frozen importlib._bootstrap>"
+        || file_name == b"<frozen importlib._bootstrap_external>"
+        || file_name == b"_frozen_importlib"
+        || file_name == b"_frozen_importlib_external"
     {
         if traceback.frame.iframe().code().obj_name.as_str() == "_call_with_frames_removed" {
             now_in_importlib = true;

diff --git a/crates/vm/src/stdlib/_imp.rs b/crates/vm/src/stdlib/_imp.rs
@@ -555,7 +555,7 @@ fn update_code_filenames(
     new_name: &'static PyStrInterned,
 ) {
     let current = code.source_path();
-    if !core::ptr::eq(current, old_name) && current.as_str() != old_name.as_str() {
+    if !core::ptr::eq(current, old_name) && current.as_wtf8() != old_name.as_wtf8() {
         return;
     }
     code.set_source_path(new_name);

diff --git a/crates/vm/src/stdlib/_io.rs b/crates/vm/src/stdlib/_io.rs
@@ -5986,8 +5986,8 @@ mod _io {
                     && let Some(code) = crate::frame::current_code()
                     && let Some(stdlib_dir) = vm.state.config.paths.stdlib_dir.as_deref()
                 {
-                    let path = code.source_path().as_str();
-                    if !path.starts_with(stdlib_dir) {
+                    let path = code.source_path().as_bytes();
+                    if !path.starts_with(stdlib_dir.as_bytes()) {
                         stacklevel = stacklevel.saturating_sub(1);
                     }
                 }