youknowone · Oct 15, 2026 · Oct 15, 2026 · Oct 15, 2026 · Oct 15, 2026 · Oct 15, 2026
diff --git a/Lib/test/datetimetester.py b/Lib/test/datetimetester.py
@@ -6820,6 +6820,7 @@ class IranTest(ZoneInfoTest):
     zonename = 'Asia/Tehran'
 
 
+@unittest.skip("TODO: RUSTPYTHON; setUp needs _testcapi.test_datetime_capi")
 @unittest.skipIf(_testcapi is None, 'need _testcapi module')
 class CapiTest(unittest.TestCase):
     def setUp(self):

diff --git a/Lib/test/test_buffer.py b/Lib/test/test_buffer.py
@@ -4593,6 +4593,7 @@ def test_call_builtins(self):
         with self.assertRaises(OverflowError):
             ba.__buffer__(sys.maxsize + 1)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; needs _testcapi.testBuf
     @unittest.skipIf(_testcapi is None, "requires _testcapi")
     def test_c_buffer(self):
         buf = _testcapi.testBuf()
@@ -4610,12 +4611,14 @@ def test_c_buffer(self):
             buf.__release_buffer__(mv)
         self.assertEqual(buf.references, 0)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; needs _testcapi.testBuf
     @unittest.skipIf(_testcapi is None, "requires _testcapi")
     def test_c_buffer_invalid_flags(self):
         buf = _testcapi.testBuf()
         self.assertRaises(SystemError, buf.__buffer__, PyBUF_READ)
         self.assertRaises(SystemError, buf.__buffer__, PyBUF_WRITE)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; needs _testcapi.buffer_fill_info
     @unittest.skipIf(_testcapi is None, "requires _testcapi")
     def test_c_fill_buffer_invalid_flags(self):
         # PyBuffer_FillInfo
@@ -4625,6 +4628,7 @@ def test_c_fill_buffer_invalid_flags(self):
         self.assertRaises(SystemError, _testcapi.buffer_fill_info,
                           source, 0, PyBUF_WRITE)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; needs _testcapi.buffer_fill_info
     @unittest.skipIf(_testcapi is None, "requires _testcapi")
     def test_c_fill_buffer_readonly_and_writable(self):
         source = b"abc"

diff --git a/Lib/test/test_bytes.py b/Lib/test/test_bytes.py
@@ -1171,6 +1171,7 @@ def __bytes__(self):
                               BytesSubclass(b'abc'))
 
     # Test PyBytes_FromFormat()
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; needs ctypes.pythonapi
     def test_from_format(self):
         ctypes = import_helper.import_module('ctypes')
         _testcapi = import_helper.import_module('_testcapi')

diff --git a/Lib/test/test_call.py b/Lib/test/test_call.py
@@ -306,16 +306,19 @@ def test_o(self):
     def test_o_ext(self):
         self.assertEqual(self.obj.meth_o(*[1]), (self.expected_self, 1))
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; built-in argument count error message differs
     def test_o_error_no_arg(self):
         msg = r"meth_o\(\) takes exactly one argument \(0 given\)"
         self.assertRaisesRegex(TypeError, msg, self.obj.meth_o)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; built-in argument count error message differs
     def test_o_error_two_args(self):
         msg = r"meth_o\(\) takes exactly one argument \(2 given\)"
         self.assertRaisesRegex(
             TypeError, msg, lambda: self.obj.meth_o(1, 2),
         )
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; built-in argument count error message differs
     def test_o_error_ext(self):
         msg = r"meth_o\(\) takes exactly one argument \(3 given\)"
         self.assertRaisesRegex(
@@ -340,18 +343,21 @@ def test_noargs(self):
     def test_noargs_ext(self):
         self.assertEqual(self.obj.meth_noargs(*[]), self.expected_self)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; built-in argument count error message differs
     def test_noargs_error_arg(self):
         msg = r"meth_noargs\(\) takes no arguments \(1 given\)"
         self.assertRaisesRegex(
             TypeError, msg, lambda: self.obj.meth_noargs(1),
         )
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; built-in argument count error message differs
     def test_noargs_error_arg2(self):
         msg = r"meth_noargs\(\) takes no arguments \(2 given\)"
         self.assertRaisesRegex(
             TypeError, msg, lambda: self.obj.meth_noargs(1, 2),
         )
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; built-in argument count error message differs
     def test_noargs_error_ext(self):
         msg = r"meth_noargs\(\) takes no arguments \(3 given\)"
         self.assertRaisesRegex(
@@ -541,6 +547,7 @@ def check_result(self, result, expected):
                 expected = (*expected[:-1], result[-1])
         self.assertEqual(result, expected)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; needs _testcapi.pyobject_fastcalldict
     @unittest.skipIf(_testcapi is None, "requires _testcapi")
     def test_vectorcall_dict(self):
         # Test PyObject_VectorcallDict()
@@ -561,6 +568,7 @@ def test_vectorcall_dict(self):
                 result = _testcapi.pyobject_fastcalldict(func, args, kwargs)
                 self.check_result(result, expected)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; needs _testcapi.pyobject_vectorcall
     @unittest.skipIf(_testcapi is None, "requires _testcapi")
     def test_vectorcall(self):
         # Test PyObject_Vectorcall()
@@ -626,6 +634,7 @@ def testfunction_kw(self, *, kw):
 @unittest.skipIf(_testcapi is None, "requires _testcapi")
 class TestPEP590(unittest.TestCase):
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; wrapper_descriptor lacks Py_TPFLAGS_METHOD_DESCRIPTOR
     def test_method_descriptor_flag(self):
         import functools
         cached = functools.lru_cache(1)(testfunction)
@@ -645,6 +654,7 @@ class MethodDescriptorHeap(_testcapi.MethodDescriptorBase):
             pass
         self.assertFalse(MethodDescriptorHeap.__flags__ & Py_TPFLAGS_METHOD_DESCRIPTOR)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; needs _testcapi.MethodDescriptorBase
     def test_vectorcall_flag(self):
         self.assertTrue(_testcapi.MethodDescriptorBase.__flags__ & Py_TPFLAGS_HAVE_VECTORCALL)
         self.assertTrue(_testcapi.MethodDescriptorDerived.__flags__ & Py_TPFLAGS_HAVE_VECTORCALL)
@@ -666,6 +676,7 @@ def __call__(self):
                 pass
         self.assertFalse(MethodDescriptorHeap.__flags__ & Py_TPFLAGS_HAVE_VECTORCALL)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; needs _testcapi.MethodDescriptorNopGet
     def test_vectorcall_override(self):
         # Check that tp_call can correctly override vectorcall.
         # MethodDescriptorNopGet implements tp_call but it inherits from
@@ -676,6 +687,7 @@ def test_vectorcall_override(self):
         f = _testcapi.MethodDescriptorNopGet()
         self.assertIs(f(*args), args)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; needs _testcapi.make_vectorcall_class
     def test_vectorcall_override_on_mutable_class(self):
         """Setting __call__ should disable vectorcall"""
         TestType = _testcapi.make_vectorcall_class()
@@ -686,6 +698,7 @@ def test_vectorcall_override_on_mutable_class(self):
         TestType.__call__ = lambda self: "custom"
         self.assertEqual(instance(), "custom")
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; needs _testcapi.make_vectorcall_class
     def test_vectorcall_override_with_subclass(self):
         """Setting __call__ on a superclass should disable vectorcall"""
         SuperType = _testcapi.make_vectorcall_class()
@@ -728,6 +741,7 @@ class DerivedType(SuperType):
         self.assertEqual(_testcapi.has_vectorcall_flag(UnaffectedType2), True)
 
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; needs _testcapi.MethodDescriptorBase
     def test_vectorcall(self):
         # Test a bunch of different ways to call objects:
         # 1. vectorcall using PyVectorcall_Call()
@@ -804,6 +818,7 @@ def __call__(self, *args):
                 self.assertEqual(expected, meth(*args1, **kwargs))
                 self.assertEqual(expected, wrapped(*args, **kwargs))
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; needs _testcapi.function_setvectorcall
     def test_setvectorcall(self):
         from _testcapi import function_setvectorcall
         _testinternalcapi = import_helper.import_module("_testinternalcapi")
@@ -815,6 +830,7 @@ def f(num): return num + 1
         for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
             assert_equal("overridden", f(num))
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; needs _testcapi.function_setvectorcall
     def test_setvectorcall_load_attr_specialization_skip(self):
         from _testcapi import function_setvectorcall
         _testinternalcapi = import_helper.import_module("_testinternalcapi")
@@ -832,6 +848,7 @@ def __getattribute__(self, attr):
         for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
             assert_equal("overridden", x.a)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; needs _testcapi.function_setvectorcall
     def test_setvectorcall_load_attr_specialization_deopt(self):
         from _testcapi import function_setvectorcall
         _testinternalcapi = import_helper.import_module("_testinternalcapi")
@@ -1117,6 +1134,7 @@ def test_function_with_many_args(self):
 
 @unittest.skipIf(_testcapi is None, 'need _testcapi')
 class TestCAPI(unittest.TestCase):
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; needs _testcapi.pycfunction_call
     def test_cfunction_call(self):
         def func(*args, **kwargs):
             return (args, kwargs)

diff --git a/Lib/test/test_descr.py b/Lib/test/test_descr.py
@@ -815,6 +815,7 @@ class X(C, int()):
             class X(int(), C):
                 pass
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; needs _testcapi.HeapCTypeMetaclassNullNew
     @unittest.skipIf(_testcapi is None, 'need the _testcapi module')
     def test_type_with_null_new_metaclass(self):
         metaclass = _testcapi.HeapCTypeMetaclassNullNew
@@ -5099,6 +5100,7 @@ def __call__(self, arg):
         self.assertRegex(repr(method),
             r"<bound method qualname of <object object at .*>>")
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; needs _testcapi.bad_get
     @unittest.skipIf(_testcapi is None, 'need the _testcapi module')
     def test_bpo25750(self):
         # bpo-25750: calling a descriptor (implemented as built-in

diff --git a/Lib/test/test_dis.py b/Lib/test/test_dis.py
@@ -1100,6 +1100,7 @@ def test_dis_with_some_positions(self):
         ])
         self.do_disassembly_test(f, expect, show_positions=True)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AST nodes without columns compile to column 0
     @requires_debug_ranges()
     def test_dis_with_linenos_but_no_columns(self):
         code = "def f():\n\tx = 1"

diff --git a/Lib/test/test_inspect/test_inspect.py b/Lib/test/test_inspect/test_inspect.py
@@ -3387,6 +3387,7 @@ def test_signature_on_builtins_no_signature(self):
                 self.assertEqual(inspect.signature(builtin),
                                  inspect.signature(template))
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; needs _testcapi.DocStringUnrepresentableSignatureTest
     @unittest.skipIf(MISSING_C_DOCSTRINGS,
                      "Signature information for builtins requires docstrings")
     def test_signature_parsing_with_defaults(self):

diff --git a/Lib/test/test_int.py b/Lib/test/test_int.py
@@ -721,6 +721,10 @@ def test_int_from_other_bases(self):
         with self.subTest(base=base):
             self._other_base_helper(base)
 
+    @unittest.expectedFailureIf(
+        sys.platform == "wasi",
+        "TODO: RUSTPYTHON; subinterpreters need the threading feature",
+    )
     def test_int_max_str_digits_is_per_interpreter(self):
         # Changing the limit in one interpreter does not change others.
         code = """if 1:

diff --git a/Lib/test/test_pyexpat.py b/Lib/test/test_pyexpat.py
@@ -1007,6 +1007,7 @@ class ExternalEntityParserCreateErrorTest(unittest.TestCase):
     def setUpClass(cls):
         cls.testcapi = import_helper.import_module('_testcapi')
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; needs _testcapi.set_nomemory
     @unittest.skipIf(support.Py_TRACE_REFS,
                      'Py_TRACE_REFS conflicts with testcapi.set_nomemory')
     def test_error_path_no_crash(self):
@@ -1294,6 +1295,10 @@ def test_set_activation_threshold__fail_for_subparser(self):
     def test_set_activation_threshold__invalid_threshold_type(self):
         return super().test_set_activation_threshold__invalid_threshold_type()
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'xmlparser' object has no attribute 'SetBillionLaughsAttackProtectionActivationThreshold'
+    def test_set_activation_threshold__invalid_threshold_range(self):
+        return super().test_set_activation_threshold__invalid_threshold_range()
+
     @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'xmlparser' object has no attribute 'SetBillionLaughsAttackProtectionMaximumAmplification'
     def test_set_maximum_amplification__fail_for_subparser(self):
         return super().test_set_maximum_amplification__fail_for_subparser()

diff --git a/Lib/test/test_signal.py b/Lib/test/test_signal.py
@@ -353,6 +353,7 @@ def check_signum(signals):
 
         assert_python_ok('-c', code)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; wakeup fd write errors are not reported
     @unittest.skipIf(_testcapi is None, 'need _testcapi')
     @unittest.skipUnless(hasattr(os, "pipe"), "requires os.pipe()")
     def test_wakeup_write_error(self):
@@ -534,6 +535,7 @@ def handler(signum, frame):
 
         assert_python_ok('-c', code)
 
+    @unittest.expectedFailureIf(os.name != 'nt', "TODO: RUSTPYTHON; wakeup fd write errors are not reported")
     @unittest.skipIf(_testcapi is None, 'need _testcapi')
     def test_send_error(self):
         # Use a subprocess to have only one thread.
@@ -577,6 +579,7 @@ def handler(signum, frame):
         """.format(action=action)
         assert_python_ok('-c', code)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; wakeup fd write errors are not reported
     @unittest.skipIf(_testcapi is None, 'need _testcapi')
     def test_warn_on_full_buffer(self):
         # Use a subprocess to have only one thread.

diff --git a/Lib/test/test_socket.py b/Lib/test/test_socket.py
@@ -1758,6 +1758,7 @@ def test_getaddrinfo_localized_error(self):
                                flags=socket.AI_NUMERICSERV)
         str(cm.exception)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; TypeError for an out-of-range int port
     @unittest.skipIf(_testcapi is None, "requires _testcapi")
     def test_getaddrinfo_int_port_overflow(self):
         # gh-74895: Test that getaddrinfo does not raise OverflowError on port.

diff --git a/Lib/test/test_sqlite3/test_hooks.py b/Lib/test/test_sqlite3/test_hooks.py
@@ -177,6 +177,7 @@ def handler(*a, **kw):
         self.cx.set_authorizer(handler)
         self.assert_not_authorized(self.cx.execute, "select * from test")
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; unraisable exception handling not implemented
     @with_tracebacks(OverflowError)
     def test_authorizer_concurrent_mutation_with_overflown_value(self):
         _testcapi = import_helper.import_module("_testcapi")

diff --git a/Lib/test/test_threading.py b/Lib/test/test_threading.py
@@ -1630,7 +1630,6 @@ def pipe(self):
             os.set_blocking(r, False)
         return (r, w)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_threads_join(self):
         # Non-daemon threads should be joined at subinterpreter shutdown
         # (issue #18808)
@@ -1659,7 +1658,6 @@ def f():
         # The thread was joined properly.
         self.assertEqual(os.read(r, 1), b"x")
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_threads_join_2(self):
         # Same as above, but a delay gets introduced after the thread's
         # Python code returned but before the thread state is deleted.

diff --git a/Lib/test/test_threading_local.py b/Lib/test/test_threading_local.py
@@ -197,6 +197,7 @@ class X:
         self.assertIsNone(wr())
 
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; needs _testcapi.call_in_temporary_c_thread
     def test_threading_local_clear_race(self):
         # See https://github.com/python/cpython/issues/100892
 

diff --git a/Lib/test/test_zipimport.py b/Lib/test/test_zipimport.py
@@ -843,7 +843,6 @@ def doTraceback(self, module):
         else:
             raise AssertionError("This ought to be impossible")
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON; empty caret lines from equal col/end_col
     def testTraceback(self):
         files = {TESTMOD + ".py": raise_src}
         self.doTest(None, files, TESTMOD, call=self.doTraceback)

diff --git a/crates/compiler-core/src/bytecode.rs b/crates/compiler-core/src/bytecode.rs
@@ -3,7 +3,10 @@
 
 use crate::{
     marshal::MarshalError,
-    varint::{read_varint, read_varint_with_start, write_varint_be, write_varint_with_start},
+    varint::{
+        read_varint, read_varint_with_start, write_signed_varint, write_varint_be,
+        write_varint_with_start,
+    },
     {OneIndexed, SourceLocation},
 };
 use alloc::{borrow::ToOwned, boxed::Box, collections::BTreeSet, fmt, string::String, vec::Vec};
@@ -143,6 +146,66 @@ pub fn decode_exception_table(table: &[u8]) -> Vec<ExceptionTableEntry> {
     entries
 }
 
+/// scan_varint
+fn scan_varint(data: &[u8]) -> u32 {
+    let mut iter = data.iter();
+    let mut read = iter.next().copied().unwrap_or(0);
+    let mut val = u32::from(read & 63);
+    let mut shift = 0;
+    while read & 64 != 0 {
+        read = iter.next().copied().unwrap_or(0);
+        shift += 6;
+        val |= u32::from(read & 63) << shift;
+    }
-fn scan_varint(data: &[u8]) -> u32 {
-    let mut iter = data.iter();
-    let mut read = iter.next().copied().unwrap_or(0);
-    let mut val = u32::from(read & 63);
-    let mut shift = 0;
-    while read & 64 != 0 {
-        read = iter.next().copied().unwrap_or(0);
-        shift += 6;
-        val |= u32::from(read & 63) << shift;
-    }
+fn scan_varint(data: &[u8]) -> u32 {
+    let mut iter = data.iter();
+    let mut read = iter.next().copied().unwrap_or(0);
+    let mut val = u32::from(read & 63);
+    let mut shift = 0;
+    while read & 64 != 0 {
+        read = iter.next().copied().unwrap_or(0);
+        shift += 6;
+        if shift >= 32 {
+            break;
+        }
+        val |= u32::from(read & 63) << shift;
+    }
-fn scan_varint(data: &[u8]) -> u32 {
-    let mut iter = data.iter();
-    let mut read = iter.next().copied().unwrap_or(0);
-    let mut val = u32::from(read & 63);
-    let mut shift = 0;
-    while read & 64 != 0 {
-        read = iter.next().copied().unwrap_or(0);
-        shift += 6;
-        val |= u32::from(read & 63) << shift;
-    }
+fn scan_varint(data: &[u8]) -> u32 {
+    let mut iter = data.iter();
+    let mut read = iter.next().copied().unwrap_or(0);
+    let mut val = u32::from(read & 63);
+    let mut shift = 0;
+    while read & 64 != 0 {
+        read = iter.next().copied().unwrap_or(0);
+        shift += 6;
+        if shift >= 32 {
+            break;
+        }
+        val |= u32::from(read & 63) << shift;
+    }
+    val
+}
+
+/// scan_signed_varint
+fn scan_signed_varint(data: &[u8]) -> i32 {
+    let uval = scan_varint(data);
+    if uval & 1 != 0 {
+        -((uval >> 1) as i32)
+    } else {
+        (uval >> 1) as i32
+    }
+}
+
+/// get_line_delta
+fn get_line_delta(entry: &[u8]) -> i32 {
+    match PyCodeLocationInfoKind::from_code((entry[0] >> 3) & 15) {
+        Some(PyCodeLocationInfoKind::NoColumns | PyCodeLocationInfoKind::Long) => {
+            scan_signed_varint(&entry[1..])
+        }
+        Some(PyCodeLocationInfoKind::OneLine1) => 1,
+        Some(PyCodeLocationInfoKind::OneLine2) => 2,
+        // None, OneLine0 and the short forms stay on the same line.
+        _ => 0,
+    }
+}
+
+/// remove_column_info: rewrite every entry of a linetable that has a
+/// location as a NO_COLUMNS entry with the same length and line delta.
+#[must_use]
+pub fn remove_column_info(locations: &[u8]) -> Vec<u8> {
+    let mut output = Vec::with_capacity(locations.len());
+    let mut offset = 0;
+    while offset < locations.len() {
+        let header = locations[offset];
+        if (header >> 3) & 15 == PyCodeLocationInfoKind::None as u8 {
+            output.push(header);
+        } else {
+            let blength = (header & 7) + 1;
+            output.push(0x80 | ((PyCodeLocationInfoKind::NoColumns as u8) << 3) | (blength - 1));
+            write_signed_varint(&mut output, get_line_delta(&locations[offset..]));
+        }
+        offset += 1;
+        while offset < locations.len() && locations[offset] & 128 == 0 {
+            offset += 1;
+        }
+    }
+    output
+}
+
 /// Parse linetable to build a boolean mask indicating which code units
 /// have NO_LOCATION (line == -1). Returns a Vec<bool> of length `num_units`.
 #[must_use]